From 431578ba46801bd014fc49e8a12a8f763b6e74d9 Mon Sep 17 00:00:00 2001 From: Gerardo Date: Tue, 12 Mar 2024 12:38:23 +0100 Subject: [PATCH] Restricciones angulos en modos de viaje --- Olivia/olv.h | 1 + Olivia/olv_geom.cpp | 11 +- Olivia/olv_limp.cpp | 33 +- Olivia/olv_limp.h | 6 +- Olivia/olv_limp_def.h | 6 +- Olivia/olv_limp_thr.cpp | 1539 ++++++++++++++------------ Olivia/olv_limp_thr.h | 3 + OliviaTasks/OliviaTasks.cpp | 1 + OliviaTasks/OliviaTasks.rc | 8 +- OliviaTasks/OliviaTasks.vcxproj.user | 2 +- includes/Olivia/OliviaDef.cs | 8 +- 11 files changed, 908 insertions(+), 710 deletions(-) diff --git a/Olivia/olv.h b/Olivia/olv.h index 842cbd3..41d53c1 100644 --- a/Olivia/olv.h +++ b/Olivia/olv.h @@ -72,6 +72,7 @@ typedef struct PathsOlv{ char path_res_sec[MAX_PATH]; /// 1) res = 1; if (res < -1) res = -1; + /*if (pscalar < 0) + { + res = acos(res); + if (res < 0) + return OLV_PI + res; + else + return OLV_PI - res; + }*/ return acos(res); } //************************************************************************************* diff --git a/Olivia/olv_limp.cpp b/Olivia/olv_limp.cpp index 8a6bf76..213aec6 100644 --- a/Olivia/olv_limp.cpp +++ b/Olivia/olv_limp.cpp @@ -19,6 +19,7 @@ Colv_limp::Colv_limp(COlivia *olv) nod_plant=-1; this->olv = olv; res_circ=OLV_RES_NO; + res_angulos = OLV_RES_NO; npts_ctrl = 3; uds_tto = OliviaDef::GeneralDef::OlvTipTtoNoDef; v_despl = 5; @@ -33,7 +34,7 @@ Colv_limp::Colv_limp(COlivia *olv) memset(coor_instal,0,3*sizeof(double)); thr_limp = new Colv_limp_thr(this); //cost_amb=NULL; - n_nw=n_amb=0; + n_nw=n_amb= n_nwc=0; pp=-1; tipo_ambit=-1; inww_amb=NULL; @@ -366,6 +367,11 @@ int Colv_limp::pon_config(char *config_) if(!olv->dame_param(token, olv->paths.path_nw, sizeof(olv->paths.path_nw))) break; } + else if (strstr(token, OliviaDef::GeneralDef::GG_pnc)) + { + if (!olv->dame_param(token, olv->paths.path_nwc, sizeof(olv->paths.path_nwc))) + break; + } //los campos a leer de la dbf else if(strstr(token,OliviaDef::GeneralDef::GAA_obser)) { @@ -436,6 +442,18 @@ int Colv_limp::pon_config(char *config_) if (!olv->dame_param(token, (int*)&revisa_topo)) break; + } + else if (strstr(token, OliviaDef::GeneralDef::GG_angu)) + { + if (!olv->dame_param(token, &res_angulos)) + break; + + } + else if (strstr(token, OliviaDef::GeneralDef::GG_conj)) + { + if (!olv->dame_param(token, (int*)&revisa_conju)) + break; + } //los campos a leer de la dbf de la red navegable /*else if (strstr(token, OliviaDef::GeneralDef::GTC_onew)) @@ -730,10 +748,8 @@ BOOL Colv_limp::guarda_campos_ini(char *path) } //************************************************************************************* -#define NOMB_CAMP_CONJ_TO "T_JNCTID" -#define NOMB_CAMP_CONJ_FROM "F_JNCTID" -#define NOMB_CAMP_ELEV_TO "T_ELEV" -#define NOMB_CAMP_ELEV_FROM "F_ELEV" +#define NOMB_CAMP_ELEV_TO "_elev_t" +#define NOMB_CAMP_ELEV_FROM "_elev_f" /** * Rellena los nombres de los campos de la dbf */ @@ -745,10 +761,11 @@ void Colv_limp::rellena_campos() sprintf_s(camps.campo_velo,OLV_LIMP_MAX_CAMP,"_vel"); sprintf_s(camps.campo_fow,OLV_LIMP_MAX_CAMP,"_pea"); sprintf_s(camps.campo_name,OLV_LIMP_MAX_CAMP,"_dir"); - sprintf_s(camps.campo_name, OLV_LIMP_MAX_CAMP, "_evita"); + sprintf_s(camps.campo_evi, OLV_LIMP_MAX_CAMP, "_evita"); + sprintf_s(camps.campo_ang, OLV_LIMP_MAX_CAMP, "_angulo"); + + //TOM TOM ELEV - sprintf_s(camps.campo_conj_to, OLV_LIMP_MAX_CAMP, NOMB_CAMP_CONJ_TO); - sprintf_s(camps.campo_conj_from, OLV_LIMP_MAX_CAMP, NOMB_CAMP_CONJ_FROM); sprintf_s(camps.campo_elev_to, OLV_LIMP_MAX_CAMP, NOMB_CAMP_ELEV_TO); sprintf_s(camps.campo_elev_from, OLV_LIMP_MAX_CAMP, NOMB_CAMP_ELEV_FROM); diff --git a/Olivia/olv_limp.h b/Olivia/olv_limp.h index 8854f8b..96a3a7b 100644 --- a/Olivia/olv_limp.h +++ b/Olivia/olv_limp.h @@ -35,13 +35,15 @@ public: int pp; /// iaso; /// *tramos; diff --git a/Olivia/olv_limp_def.h b/Olivia/olv_limp_def.h index 71db68b..7939e32 100644 --- a/Olivia/olv_limp_def.h +++ b/Olivia/olv_limp_def.h @@ -262,6 +262,8 @@ typedef struct Info_aso_reco typedef struct Info_aso2 { INT64 flgs; //flags + float velReal; + float angulo; 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 @@ -287,6 +289,7 @@ typedef struct Info_aso2 inf_r.id=inf_n.nomb=0; inf_n.velo=inf_l.ancho=inf_r.kg=-1; inf_r.uds=0; + angulo = 0; }; void del() { @@ -441,9 +444,8 @@ typedef struct Campos_dbf char campo_name[OLV_LIMP_MAX_CAMP]; char campo_fow[OLV_LIMP_MAX_CAMP]; char campo_evi[OLV_LIMP_MAX_CAMP]; + char campo_ang[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]; ///////////////////////////////////////////// diff --git a/Olivia/olv_limp_thr.cpp b/Olivia/olv_limp_thr.cpp index 611172c..1396724 100644 --- a/Olivia/olv_limp_thr.cpp +++ b/Olivia/olv_limp_thr.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #ifdef OLIVIA_COMPILA //olivia @@ -85,8 +85,8 @@ void Colv_limp_thr::inicia_th() //************************************************************************************* /** - * Cola de procesos en la que el thread está iterando y va ejecutando la tarea que le toque en cada momento - * También se usa en los subprocesos, cuando el proceso principal lanza los subprocesos, cada uno itera en una cola como esta + * Cola de procesos en la que el thread está iterando y va ejecutando la tarea que le toque en cada momento + * También se usa en los subprocesos, cuando el proceso principal lanza los subprocesos, cada uno itera en una cola como esta */ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *clase,Param_olv_limp_thr *e) { @@ -124,7 +124,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_BARRMIX_SUB: { - //aquí entran los subthreads para hacer las comprobaciones del barrido mixto + //aquí entran los subthreads para hacer las comprobaciones del barrido mixto //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -134,7 +134,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_BARRMIX_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea this_i->n_subthr_fin++; if(this_i->n_subthr_fin==this_i->n_subthr) @@ -152,10 +152,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla { int soloi=-1; bien=this_i->une_amb_nw(soloi); - if (bien && this_i->olv_limp->revisa_topo) - { - this_i->corrije_topo_nw(); - } + if(bien && (this_i->olv->modo_ejecpirate)//sigue { if(this_i->olv_limp->tipo_ambit==OLV_AMB_LIN) @@ -172,7 +169,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COMPCORT_SUB: { - //aquí entran los subthreads para hacer los cálculos de distancia, cuando acaban + //aquí entran los subthreads para hacer los cálculos de distancia, cuando acaban //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -182,7 +179,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COMPCORT_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea this_i->n_subthr_fin++; if(this_i->n_subthr_fin==this_i->n_subthr) @@ -199,13 +196,21 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla case OLV_LIMP_EV_TOPO_NW: { bien=this_i->topo_nw(); + if (bien && this_i->olv_limp->revisa_topo) + { + this_i->corrije_topo_nw(); + } + if (bien && this_i->olv_limp->revisa_conju) + { + this_i->corrije_conjunciones_nw(); + } if(bien && (this_i->olv->modo_ejecpirate)//sigue this_i->encola(OLV_LIMP_EV_COST_CONJ,NULL,FALSE); break; } case OLV_LIMP_EV_COST_CONJ: { - //esta tarea lanza varios subthreads para realizar los cálculos + //esta tarea lanza varios subthreads para realizar los cálculos //de costes entre conjunciones (les encola la tarea dist_conj_sub), //y estos cuando acaban le encolan al padre (el que los ha lanzado) //la tarea de dist_conj_fin @@ -214,7 +219,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COST_CONJ_SUB: { - //aquí entran los subthreads para hacer los cálculos de distancia, cuando acaban + //aquí entran los subthreads para hacer los cálculos de distancia, cuando acaban //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -224,7 +229,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COST_CONJ_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea this_i->n_subthr_fin++; @@ -241,8 +246,8 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_ANG_CONJ: { - //esta tarea lanza varios subthreads para realizar los cálculos - //de ángulos entre conjunciones (les encola la tarea ang_conj_sub), + //esta tarea lanza varios subthreads para realizar los cálculos + //de ángulos entre conjunciones (les encola la tarea ang_conj_sub), //y estos cuando acaban le encolan al padre (el que los ha lanzado) //la tarea de ang_conj_fin bien=this_i->calcula_ang_conj(); @@ -250,7 +255,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_ANG_CONJ_SUB: { - //aquí entran los subthreads para hacer los cálculos de ángulos, cuando acaban + //aquí entran los subthreads para hacer los cálculos de ángulos, cuando acaban //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -260,7 +265,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_ANG_CONJ_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea this_i->n_subthr_fin++; if(this_i->n_subthr_fin==this_i->n_subthr) @@ -289,7 +294,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_GUARD_MATS_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea this_i->n_subthr_fin++; int i; @@ -326,7 +331,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla else if(e->id_e==-2) { bien=FALSE; - this_i->pon_mi_msg("Errores en cálculo multitask, no ha habido conexión"); + this_i->pon_mi_msg("Errores en cálculo multitask, no ha habido conexión"); break; } } @@ -340,7 +345,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla if(in_subthr) { bien=FALSE; - this_i->pon_mi_msg("Errores en cálculo multitask"); + this_i->pon_mi_msg("Errores en cálculo multitask"); break; } this_i->task_dj_fin(); @@ -351,7 +356,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COST_AMB: { - //esta tarea lanza varios subthreads para realizar los cálculos + //esta tarea lanza varios subthreads para realizar los cálculos //de costes(les encola la tarea dist_amb_sub), //y estos cuando acaban le encolan al padre (el que los ha lanzado) //la tarea de dist_amb_fin @@ -360,7 +365,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COST_AMB_SUB: { - //aquí entran los subthreads para hacer los cálculos de costes entre ámbitos, cuando acaban + //aquí entran los subthreads para hacer los cálculos de costes entre ámbitos, cuando acaban //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -370,7 +375,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_COST_AMB_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea int i; this_i->n_subthr_fin++; @@ -383,17 +388,17 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla if(in_subthr) { bien=FALSE; - this_i->pon_mi_msg("Errores al calcular coste entre ámbitos"); + this_i->pon_mi_msg("Errores al calcular coste entre ámbitos"); break; } bien=this_i->calcula_cost_amb_fin(); if(bien && (this_i->olv->modo_ejecpirate)//sigue { - if(this_i->olv->modo_ejec==OLV_EJEC_PLAN) //lee info de sectorización y va a planif + if(this_i->olv->modo_ejec==OLV_EJEC_PLAN) //lee info de sectorización y va a planif this_i->encola(OLV_LIMP_EV_LEE_SECTO,NULL,FALSE); else //sectoriza { - if(this_i->olv_limp->nsec==0)//hay que calcular el número de sectores + if(this_i->olv_limp->nsec==0)//hay que calcular el número de sectores this_i->encola(OLV_LIMP_EV_CALC_NSEC,NULL,FALSE); else { @@ -451,7 +456,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_PLANIFICA_SUB: { - //aquí entran los subthreads para hacer los cálculos de planificación, cuando acaban + //aquí entran los subthreads para hacer los cálculos de planificación, cuando acaban //encolan al padre la tarea de fin int ithr; if(e!=NULL) @@ -461,7 +466,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_PLANIFICA_FIN: { - //aquí entra el padre cuando van acabando los subthreads + //aquí entra el padre cuando van acabando los subthreads //si han terminado todos encola la siguiente tarea int i; this_i->n_subthr_fin++; @@ -494,7 +499,7 @@ void Colv_limp_thr::cola_proc(int evento, OlvAsync_cola *cla } case OLV_LIMP_EV_SUBTHR_PROG: { - //aquí entra el padre porque le encolan los subthreads para avisarle del progreso + //aquí entra el padre porque le encolan los subthreads para avisarle del progreso double pro=0; for(int i=0;in_subthr;i++) pro+=this_i->subthrs[i]->prog_subthr; @@ -531,7 +536,7 @@ void Colv_limp_thr::termina_th() } //************************************************************************************* /** - * Abre los datos de cartografía + * Abre los datos de cartografía */ BOOL Colv_limp_thr::abre_datos() { @@ -544,19 +549,19 @@ BOOL Colv_limp_thr::abre_datos() pon_mi_progre(OLV_TAREA_IMP, 0); pon_mi_msg(""); err_str[0]=0; - //abre la cartografía con los datos + //abre la cartografía con los datos if(!olv_limp->carto.importShp(olv_limp->olv->paths.path_data)) { - pon_mi_msg("Error en la importación del archivo\n%s",olv_limp->olv->paths.path_data); + pon_mi_msg("Error en la importación del archivo\n%s",olv_limp->olv->paths.path_data); return FALSE; } olv_limp->n_amb=olv_limp->carto.getNumberEntities(); if(olv_limp->n_amb>=USHRT_MAX) { - pon_mi_msg("Número de ámbitos (%ld) mayor que el permitido (%ld)\n",olv_limp->n_amb,USHRT_MAX); + pon_mi_msg("Número de ámbitos (%ld) mayor que el permitido (%ld)\n",olv_limp->n_amb,USHRT_MAX); return FALSE; } - //Inicializa la información asociada + //Inicializa la información asociada info_aux.reset(); //si es tipo eje de calle lo pone en el flag if((olv_limp->uds_tto==OliviaDef::GeneralDef::OlvTipTtoMh_eje) || @@ -573,14 +578,26 @@ BOOL Colv_limp_thr::abre_datos() olv_limp->iaso[info_aux.refe]=info_aux; } - //abre la cartografía de la red navegable + //abre la cartografía de la red navegable if(!olv_limp->carto.importShp(olv_limp->olv->paths.path_nw)) { - pon_mi_msg("Error en la importación del archivo\n%s",olv_limp->olv->paths.path_nw); + pon_mi_msg("Error en la importación del archivo\n%s",olv_limp->olv->paths.path_nw); return FALSE; } + olv_limp->n_nw=olv_limp->carto.getNumberEntities()-olv_limp->n_amb; - //Inicializa la información asociada + + if (olv_limp->revisa_conju) + { + if (!olv_limp->cartoAux.importShp(olv_limp->olv->paths.path_nwc)) + { + pon_mi_msg("Error en la importación del archivo de conjunciones \n%s", olv_limp->olv->paths.path_nwc); + return FALSE; + } + } + olv_limp->n_nwc = olv_limp->cartoAux.getNumberEntities(); + + //Inicializa la información asociada info_aux.reset(); info_aux.flgs = OLV_LIMP_FLG_NW; for(i=olv_limp->n_amb;in_nw+olv_limp->n_amb;i++) @@ -591,42 +608,42 @@ BOOL Colv_limp_thr::abre_datos() } ////////////////////////////////////////////////////////////////////////// - //rellena la información asociada de la red: - //sentidos de circulación, velocidad de la vía... + //rellena la información asociada de la red: + //sentidos de circulación, velocidad de la vía... if(!rellena_info_nw()) { pon_mi_msg("Error al leer info asociada a red navegable: %s", err_str); return FALSE; } ////////////////////////////////////////////////////////////////////////// - //revisa info de elevación + //revisa info de elevación if (olv_limp->revisa_elev) { rellena_elev_nw(); if (!revisa_elev_nw()) { - pon_mi_msg("Error al revisar información de elevación"); + pon_mi_msg("Error al revisar información de elevación"); } } //////////////////// - olvlog(LOG_TODO,"olv_limp_t","Finaliza Abrir datos con éxito"); + olvlog(LOG_TODO,"olv_limp_t","Finaliza Abrir datos con éxito"); return TRUE; } //************************************************************************************* /** - * Rellena la información asociada de la red navegable y los datos de limpieza + * Rellena la información asociada de la red navegable y los datos de limpieza */ BOOL Colv_limp_thr::rellena_datos() { if(!rellena_info_amb()) { - pon_mi_msg("Error al leer info asociada a ámbitos: %s", err_str); + pon_mi_msg("Error al leer info asociada a ámbitos: %s", err_str); return FALSE; } - olvlog(LOG_TODO,"olv_limp_t","Finaliza Rellena datos con éxito"); + olvlog(LOG_TODO,"olv_limp_t","Finaliza Rellena datos con éxito"); return TRUE; } @@ -658,7 +675,7 @@ BOOL Colv_limp_thr::mejora_barr_mix_fin() */ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) { - //recorre los ámbitos + //recorre los ámbitos int i,j; int refe_ace, refe_otro, refe_ant; int na_desp,na_ini, na_fin, seg; @@ -673,7 +690,7 @@ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Comprueba Barr Mix Ambs %04d a %04d", ithr, na_ini, na_fin); seg = GetTickCount(); - //Bucle en los ámbitos + //Bucle en los ámbitos for(i=na_ini;icarto.get(i); @@ -693,11 +710,11 @@ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) continue; //recorre ambas rectas a la par - //para ello, primero mira cuál es la más larga + //para ello, primero mira cuál es la más larga lon_ace = ient_ace.getLong(); lon_otro = ient_otro.getLong(); - //parte de la más corta, y avanza en pasos del PORC_AVANCE% de su longitud + //parte de la más corta, y avanza en pasos del PORC_AVANCE% de su longitud if(lon_aceiaso[refe_ace].refe2==-1) { //es la primera vez que ecuentra un bordillo paralelo @@ -731,11 +748,11 @@ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) olv_limp->iaso[refe_otro].flgs=olv_limp->iaso[refe_otro].flgs | OLV_LIMP_FLG_AMB_NO; //coge el anterior olv_limp->iaso[refe_otro].refe2=refe_ant; - //le añade un delta de ancho al anterior para que compense la longitud del nuevo + //le añade un delta de ancho al anterior para que compense la longitud del nuevo lon_ant=olv_limp->carto.getRef(refe_ant).getLong(); da=lon_otro*olv_limp->iaso[refe_otro].inf_l.ancho/lon_ant; olv_limp->iaso[refe_ant].inf_l.ancho+=da; - //renombra el otro como el anterior, para añadirle la acera + //renombra el otro como el anterior, para añadirle la acera refe_otro=refe_ant; } //olv_limp->iaso[refe_ace].refe2=refe_otro; @@ -743,11 +760,11 @@ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) //suma los anchos de forma ponderada pond=lon_ace/lon_otro; if(pond>1) - pond=1; //cuando la acera es más grande, se suma el ancho de la acera, no se amplia + pond=1; //cuando la acera es más grande, se suma el ancho de la acera, no se amplia - //cuando la acera es más pequeña, puede que en ese bordillo o banda de aparcamiento - //haya otra acera en paralelo, así que se le sumará después su ancho también, - //de forma que la suma total sea la ponderación de los anchos + //cuando la acera es más pequeña, puede que en ese bordillo o banda de aparcamiento + //haya otra acera en paralelo, así que se le sumará después su ancho también, + //de forma que la suma total sea la ponderación de los anchos olv_limp->iaso[refe_otro].inf_l.ancho += olv_limp->iaso[refe_ace].inf_l.ancho*pond; } @@ -773,20 +790,20 @@ void Colv_limp_thr::mejora_barr_mix_sub(int ithr) } //************************************************************************************* /** - * Avanza desde el primer punto de ient1 y el más próximo en ient2, + * Avanza desde el primer punto de ient1 y el más próximo en ient2, * midiendo la distancia entre las dos rectas - * devuelve si son paralelas o no en función de la dmedia y la desv + * devuelve si son paralelas o no en función de la dmedia y la desv */ BOOL Colv_limp_thr::barr_mix_paralelas(CartoBaseInfoEntity ient1, CartoBaseInfoEntity ient2) { - const double PORC_AVANCE = 0.2; //avanza en pasos del porc % de la longitud de la línea pequeña + const double PORC_AVANCE = 0.2; //avanza en pasos del porc % de la longitud de la línea pequeña //////////////////////////////////// double l_avan, dmed, desv, l_parc, long1, dis; int n; double pt[3]; - //comprueba si las puede descartar porque estén muy lejos - //mira si la distancia mínima del primer punto de ient1 a ient2 + //comprueba si las puede descartar porque estén muy lejos + //mira si la distancia mínima del primer punto de ient1 a ient2 //es muy grande para descartar if((ient2.DisPtoLine(ient1.getPto(0))>OLV_BARRMIX_DMAX_DESC) && (ient2.DisPtoLine(ient1.getPto(ient1.getNumberPtos()-1))>OLV_BARRMIX_DMAX_DESC)) return FALSE; @@ -830,8 +847,8 @@ void Colv_limp_thr::copia_info_barr_mix() } //************************************************************************************* /** - * Rellena la información de sentidos de circulación y velocidad de las vías - * en la tabla de información asociada + * Rellena la información de sentidos de circulación y velocidad de las vías + * en la tabla de información asociada */ BOOL Colv_limp_thr::rellena_info_nw() { @@ -844,15 +861,15 @@ BOOL Colv_limp_thr::rellena_info_nw() BOOL ret=TRUE,ispedestrian; olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de info asociada a carreteras"); - pon_mi_progre(OLV_TAREA_IMP, (int) (OliviaDef::GeneralDef::ProgrMax*1/3)); //1/32 porque ya ha hecho 1/3, que es la importación + pon_mi_progre(OLV_TAREA_IMP, (int) (OliviaDef::GeneralDef::ProgrMax*1/3)); //1/32 porque ya ha hecho 1/3, que es la importación ntf=nft=nboth=nno=0; sent=NULL; - //si no aplican los sentidos de circulación no se calculan, se ponen todos a todos sentidos + //si no aplican los sentidos de circulación no se calculan, se ponen todos a todos sentidos if(olv_limp->res_circ==OLV_RES_NO) { - olvlog(LOG_TODO,"olv_limp_t","No aplican sentidos de circulación, puestos todos a 'ambos'"); + olvlog(LOG_TODO,"olv_limp_t","No aplican sentidos de circulación, puestos todos a 'ambos'"); nboth=olv_limp->n_nw; } @@ -885,25 +902,25 @@ BOOL Colv_limp_thr::rellena_info_nw() return FALSE; } icampoid=dbf.findCol(olv_limp->camps.campo_oid); - + int icampoevit = dbf.findCol(olv_limp->camps.campo_evi); + //////////////////////////////////////// idd =dbf.leeNexRow(); n=0; - ia=olv_limp->n_amb;//la info aso de la nw empieza donde acaba la de los ámbitos + ia=olv_limp->n_amb;//la info aso de la nw empieza donde acaba la de los ámbitos while(idd == 1) { /////////////////////////////// ispedestrian=FALSE; + int cevita = dbf.getI(icampoevit); if (olv_limp->res_circ != OLV_RES_NO) { //("FOW" =3 OR "FOW">=7) AND ("ONEWAY" = 'N' OR "ONEWAY" = ' ' ) //si se cumple lo anterior, son como doble sentido pero no se replican ////////////////////////// - //sentido de circulación - int sentf, senft; - sentf = dbf.getI(icampstf); - senft = dbf.getI(icampsft); - + //sentido de circulación + int sentf = dbf.getI(icampstf);; + int senft = dbf.getI(icampsft); s = 0; if (sentf && senft) { @@ -921,7 +938,7 @@ BOOL Colv_limp_thr::rellena_info_nw() } else { - //no aplica la restricción por ser servicio público, cómo se sabe si es de un único sentido? + //no aplica la restricción por ser servicio público, cómo se sabe si es de un único sentido? s = OLV_LIMP_FLG_CIRC_NONE; nno++; } @@ -940,13 +957,14 @@ BOOL Colv_limp_thr::rellena_info_nw() olv_limp->iaso[ia].flgs |= s; } + /////////////////////////////// //velocidad if((olv_limp->iaso[ia].flgs & OLV_LIMP_FLG_CIRC_NONE) || ispedestrian) { - s= OLV_LIMP_VELO_CIRC_PEAT; //se le pone velo muy bajita para que intente no ir por ahí, porque son calles prohibidas + s= OLV_LIMP_VELO_CIRC_PEAT; //se le pone velo muy bajita para que intente no ir por ahí, porque son calles prohibidas //a no ser que haya un contenedor - //o si es peatonal igual, que no haga las rutas por ahí, pero sí pase a hacer tratamientos + //o si es peatonal igual, que no haga las rutas por ahí, pero sí pase a hacer tratamientos } else { @@ -957,8 +975,27 @@ BOOL Colv_limp_thr::rellena_info_nw() s=OLV_LIMP_VELO_DEF;//pone por def } - olv_limp->iaso[ia].inf_n.velo=1.0*s*OLV_KMH2MS; + olv_limp->iaso[ia].velReal = 1.0 * s * OLV_KMH2MS;; + if(cevita==0) + olv_limp->iaso[ia].inf_n.velo=1.0*s*OLV_KMH2MS; + else if(cevita >0) + { + olv_limp->iaso[ia].inf_n.velo = 1.0 * cevita * s * OLV_KMH2MS; + } + else if (cevita < 0) + { + olv_limp->iaso[ia].inf_n.velo = (-1.0/ cevita) * s * OLV_KMH2MS; + } + if (olv_limp->res_angulos == OLV_RES_NO) + { + olv_limp->iaso[ia].angulo = 0; + } + else + { + int icampo_ang = dbf.findCol(olv_limp->camps.campo_ang); + olv_limp->iaso[ia].angulo=(float) dbf.getD(icampo_ang); + } /////////////////////////////// //nombre olv_limp->iaso[ia].inf_n.nomb = (char*)malloc(dbf.getSize(icampn)+1); @@ -1002,8 +1039,8 @@ fin: } //************************************************************************************* /** - * Rellena la información de ancho de los ámbitos - * en la tabla de información asociada + * Rellena la información de ancho de los ámbitos + * en la tabla de información asociada */ BOOL Colv_limp_thr::rellena_info_amb() { @@ -1029,7 +1066,7 @@ BOOL Colv_limp_thr::rellena_info_amb() (olv_limp->uds_tto==OliviaDef::GeneralDef::OlvTipTtoM2h_eje)) modo_ejes= TRUE; - olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de info asociada a ámbitos"); + olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de info asociada a ámbitos"); pon_mi_progre(OLV_TAREA_IMP, (int) (OliviaDef::GeneralDef::ProgrMax*2/3)); tipent=tipap=obs=anc=NULL; @@ -1044,7 +1081,7 @@ BOOL Colv_limp_thr::rellena_info_amb() ret=FALSE; goto fin; } - //busca el campo de observaciones, de ancho_tipo, de tipo_entidad y tipología_aparc + //busca el campo de observaciones, de ancho_tipo, de tipo_entidad y tipología_aparc //limita el ancho del campo icampo=dbf.findCol(olv_limp->camps.campo_obs); icampa=dbf.findCol(olv_limp->camps.campo_anch); @@ -1076,7 +1113,7 @@ BOOL Colv_limp_thr::rellena_info_amb() if(!modo_ejes) { //si el campo tipo de entidad es banda_aparcamiento, el ancho es fijo, - //en función de la tipología del aparcamiento + //en función de la tipología del aparcamiento //si no, hay que leer el ancho ancho=OLV_LIMP_ANCH_DEF; @@ -1093,7 +1130,7 @@ BOOL Colv_limp_thr::rellena_info_amb() } else if(strlen(tipap)>0 && strcmp(tipap,olv_limp->camps.atr_tip_apa[OLV_ATR_TIP_AP_BAT])==0) { - //es aparcamiento en batería, ancho fijo 4 + //es aparcamiento en batería, ancho fijo 4 ancho=olv_limp->anchos_def[OLV_ANCH_DEF_APBAT]; } @@ -1151,7 +1188,7 @@ BOOL Colv_limp_thr::rellena_info_amb() { pon_mi_progre(OLV_TAREA_IMP, (int) (OliviaDef::GeneralDef::ProgrMax* ((1.0*(ia+1)/olv_limp->n_amb)/3)+2/3)); - olvlog(LOG_TODO,"olv_limp_t","Rellenando info asociada a ámbitos, %ld de %ld", + olvlog(LOG_TODO,"olv_limp_t","Rellenando info asociada a ámbitos, %ld de %ld", ia+1,olv_limp->n_amb); } @@ -1164,7 +1201,7 @@ BOOL Colv_limp_thr::rellena_info_amb() /*//imprime if (msg_[0] == 0) - sprintf_s(msg_, OLV_MAX_MSG_PROCE, "Recibidos ámbitos con oids: "); + sprintf_s(msg_, OLV_MAX_MSG_PROCE, "Recibidos ámbitos con oids: "); if (sigue_msg) sprintf_s(msg_, OLV_MAX_MSG_PROCE, "%s %ld,", msg_, olv_limp->iaso[ia].oid); if (sigue_msg && strlen(msg_) + 10 >= OLV_MAX_MSG_PROCE) @@ -1179,7 +1216,7 @@ BOOL Colv_limp_thr::rellena_info_amb() if(ian_amb) { - sprintf_s(err_str,OLV_MAX_ERR,"Error al leer información asociada ia %ld OID %ld en\n%s", ia, olv_limp->iaso[ia].oid,nfile); + sprintf_s(err_str,OLV_MAX_ERR,"Error al leer información asociada ia %ld OID %ld en\n%s", ia, olv_limp->iaso[ia].oid,nfile); ret=FALSE; goto fin; } @@ -1192,7 +1229,7 @@ BOOL Colv_limp_thr::rellena_info_amb() Sleep(OLV_T_SLEEP_MSG); }*/ - olvlog(LOG_TODO,"olv_limp_t","Finaliza Matriz de info asociada a ámbitos"); + olvlog(LOG_TODO,"olv_limp_t","Finaliza Matriz de info asociada a ámbitos"); fin: @@ -1209,7 +1246,7 @@ fin: } //************************************************************************************* /** - * Lee la info de elevación y la almacena + * Lee la info de elevación y la almacena */ void Colv_limp_thr::rellena_elev_nw() { @@ -1219,7 +1256,7 @@ void Colv_limp_thr::rellena_elev_nw() int ic_conj_to, ic_conj_from, ic_elev_to, ic_elev_from; int idd, n, num; - olvlog(LOG_TODO, "olv_limp_t", "Rellenando matriz de info de elevación de carreteras."); + olvlog(LOG_TODO, "olv_limp_t", "Rellenando matriz de info de elevación de carreteras."); //lee dbf del shp strcpy_s(nfile, MAX_PATH, olv->paths.path_nw); @@ -1233,13 +1270,13 @@ void Colv_limp_thr::rellena_elev_nw() //busca el campo del sentido "ONEWAY" y el de "KPH" ic_conj_to = ic_conj_from = ic_elev_to = ic_elev_from = -1; - ic_conj_to = dbf.findCol(olv_limp->camps.campo_conj_to); - ic_conj_from = dbf.findCol(olv_limp->camps.campo_conj_from); + //ic_conj_to = dbf.findCol(olv_limp->camps.campo_conj_to); + //ic_conj_from = dbf.findCol(olv_limp->camps.campo_conj_from); ic_elev_to = dbf.findCol(olv_limp->camps.campo_elev_to); ic_elev_from = dbf.findCol(olv_limp->camps.campo_elev_from); - if (ic_conj_to == -1 || ic_conj_from == -1 || ic_elev_to == -1 || ic_elev_from == -1) + if (/*ic_conj_to == -1/* || ic_conj_from == -1 || */ic_elev_to == -1 || ic_elev_from == -1) { - olvlog(LOG_TODO, "olv_limp_t","No encontrado campos para rellenar elevación"); + olvlog(LOG_TODO, "olv_limp_t","No encontrado campos para rellenar elevación"); return; } @@ -1274,13 +1311,13 @@ void Colv_limp_thr::rellena_elev_nw() } else err_str[0] = 0; - olvlog(LOG_TODO, "olv_limp_t", "Finaliza matriz de info de elevación de carreteras. %s",err_str); + olvlog(LOG_TODO, "olv_limp_t", "Finaliza matriz de info de elevación de carreteras. %s",err_str); } //************************************************************************************* /** - * Revisa que no haya elementos de la nw que comparten nodo pero están a distinta elevación - * si encuentra, mueve el nodo de las que están a distinta elevación + * Revisa que no haya elementos de la nw que comparten nodo pero están a distinta elevación + * si encuentra, mueve el nodo de las que están a distinta elevación */ BOOL Colv_limp_thr::revisa_elev_nw() { @@ -1291,14 +1328,14 @@ BOOL Colv_limp_thr::revisa_elev_nw() if (conj_elev.size() == 0) return TRUE; - //ha encontrado nodos con distinta elevación, mueve las coordenadas + //ha encontrado nodos con distinta elevación, mueve las coordenadas BOOL resul_mueve = mueve_distint_elev_nw(conj_elev); return resul_mueve; } //************************************************************************************* /** - * Busca y almacena los elementos que tienen nodo compartido pero a distinta elevación + * Busca y almacena los elementos que tienen nodo compartido pero a distinta elevación */ std::vector Colv_limp_thr::busca_elev_nw() { @@ -1327,7 +1364,7 @@ std::vector Colv_limp_thr::busca_elev_nw() while (thp.nth > 0) Sleep(10); //////////////////////////////////////////////// - //reune toda la información + //reune toda la información //recorre el array de todos los threads, buscando repetidos std::vector::iterator it2; int i1; @@ -1337,7 +1374,7 @@ std::vector Colv_limp_thr::busca_elev_nw() for(i1=0;i1< thp.conj_th[i].conj_elev_i.size();i1++) { ya_esta = false; - //busca que no esté esta coordenada ya en el array + //busca que no esté esta coordenada ya en el array it2 = conj_elev.begin(); while (it2 != conj_elev.end() && !ya_esta) { @@ -1361,7 +1398,7 @@ std::vector Colv_limp_thr::busca_elev_nw() } //************************************************************************************* /** - * Thread para cálculo multiproceso de búsqueda de nodos a distinta elevación + * Thread para cálculo multiproceso de búsqueda de nodos a distinta elevación */ UINT th_busca_elev_dist(LPVOID pp) { @@ -1403,12 +1440,12 @@ UINT th_busca_elev_dist(LPVOID pp) continue; if ((Colv_geom::pto_equals(info1->coord[i1], info2->coord[i2]))) //if (info1->inod[i1] == info2->inod[i2]) { - //comparten nodo, revisa elevación + //comparten nodo, revisa elevación conj_elev_nw_i2.set(info2->i_nw, i2); if (info1->elev[i1] != info2->elev[i2]) { - //distinta elevación - //añade i2 + //distinta elevación + //añade i2 conj_elev_i1.conj_nw[DIST_ELEV].push_back(conj_elev_nw_i2); } else @@ -1425,7 +1462,7 @@ UINT th_busca_elev_dist(LPVOID pp) //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 + //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); sprintf_s(conj_elev_i1.key_coord, 64, "%lf-%lf", info1->coord[i1][0], info1->coord[i1][1]); @@ -1441,7 +1478,7 @@ UINT th_busca_elev_dist(LPVOID pp) } //************************************************************************************* /** - * Thread para cálculo multiproceso de búsqueda de nodos a distinta elevación + * Thread para cálculo multiproceso de búsqueda de nodos a distinta elevación */ UINT th_busca_elev_dist_coor(LPVOID pp) { @@ -1488,12 +1525,12 @@ UINT th_busca_elev_dist_coor(LPVOID pp) continue; if ((Colv_geom::pto_equals(info1->coord[i1], info2->coord[i2]))) //if (info1->inod[i1] == info2->inod[i2]) { - //comparten nodo, revisa elevación + //comparten nodo, revisa elevación conj_elev_nw_i2.set(info2->i_nw, i2); if (info1->elev[i1] != info2->elev[i2]) { - //distinta elevación - //añade i2 + //distinta elevación + //añade i2 conj_elev_i1.conj_nw[DIST_ELEV].push_back(conj_elev_nw_i2); } else @@ -1508,7 +1545,7 @@ UINT th_busca_elev_dist_coor(LPVOID pp) //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 + //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); sprintf_s(conj_elev_i1.key_coord, 64, "%lf-%lf", info1->coord[i1][0], info1->coord[i1][1]); @@ -1524,7 +1561,7 @@ UINT th_busca_elev_dist_coor(LPVOID pp) } //************************************************************************************* /* -* Comprueba si pto está dentro de mima +* Comprueba si pto está dentro de mima */ BOOL is_pto_dentro(double* pto, double* pto_mima) { @@ -1540,11 +1577,11 @@ BOOL is_pto_dentro(double* pto, double* pto_mima) //************************************************************************************* #define MUEVE_COOR_METROS 5 /** - * Mueve las coordenadas de una conjunción de las que tienen distinta elevación + * Mueve las coordenadas de una conjunción de las que tienen distinta elevación */ BOOL Colv_limp_thr::mueve_distint_elev_nw(std::vector conj_elev) { - int ELEV_MUEVE = DIST_ELEV; //mueve los que están a distinta elev, y deja igual los que están a misma_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::vector::iterator it_conj = conj_elev.begin(); CartoBaseInfoEntity ient; std::vector::iterator it_nw; @@ -1555,14 +1592,14 @@ BOOL Colv_limp_thr::mueve_distint_elev_nw(std::vector conj_e { while (it_conj != conj_elev.end()) { - //si solo hay una no la mueve, se quedaría aislada + //si solo hay una no la mueve, se quedaría aislada if ((it_conj->conj_nw[DIST_ELEV].size() > 1) && (it_conj->conj_nw[MISMA_ELEV].size() > 1)) { - //coge las nw que están a elev distinta de 0 y les mueve su coordenada en común + //coge las nw que están a elev distinta de 0 y les mueve su coordenada en común it_nw = it_conj->conj_nw[ELEV_MUEVE].begin(); while (it_nw != it_conj->conj_nw[ELEV_MUEVE].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 + 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; @@ -1599,8 +1636,8 @@ BOOL Colv_limp_thr::mueve_distint_elev_nw(std::vector conj_e } //************************************************************************************* /** - * Replica los ámbitos cuando son tipo peatonal, añadiendo otro lineal igual que tendrá solo coste - * de desplazamiento, no de tratamiento, más los segmentos que los unen, de coste 0 + * Replica los ámbitos cuando son tipo peatonal, añadiendo otro lineal igual que tendrá solo coste + * de desplazamiento, no de tratamiento, más los segmentos que los unen, de coste 0 */ BOOL Colv_limp_thr::replica_peat() { @@ -1627,24 +1664,24 @@ BOOL Colv_limp_thr::replica_peat() break; ientcp=olv_limp->carto.get(olv_limp->carto.getNumberEntities()-1); - //Añade la info aso + //Añade la info aso info_aux.reset(); info_aux.flgs=OLV_LIMP_FLG_PEAT_REP; info_aux.refe=ientcp.entity()->ref; info_aux.refe2=ient.entity()->ref; olv_limp->iaso[info_aux.refe]=info_aux; - //añade los dos extremos + //añade los dos extremos for(j=0;j<2;j++) { for(k=0;k<2;k++) { memcpy(ptos[k],ient.getPto(j),3*sizeof(double)); } - //lo añade al carto + //lo añade al carto olv_limp->carto.add(ptos_aux); ientcp=olv_limp->carto.get(olv_limp->carto.getNumberEntities()-1); - //Añade la info aso + //Añade la info aso info_aux.reset(); info_aux.flgs=OLV_LIMP_FLG_PEAT_SEG | (j*OLV_LIMP_FLG_FIN); info_aux.refe=ientcp.entity()->ref; @@ -1661,7 +1698,7 @@ BOOL Colv_limp_thr::replica_peat() //************************************************************************************* /** * Replica las calles cuando son de doble sentido y se tienen en cuenta las restricciones - * de circulación, para que se asignen los ámbitos sólo a la calle del sentido en el que estén + * de circulación, para que se asignen los ámbitos sólo a la calle del sentido en el que estén */ BOOL Colv_limp_thr::replica_doble_sent(Info_inw_dmin *inww_ord) { @@ -1677,9 +1714,9 @@ BOOL Colv_limp_thr::replica_doble_sent(Info_inw_dmin *inww_ord) KK=olv_limp->tipo_ambit; nwcp.idPropsP=0; - //recorre los ámbitos viendo a qué calle están asignados, y si es a una + //recorre los ámbitos viendo a qué calle están asignados, y si es a una //de doble sentido, se replica la calle y se pone cada una de un sentido, y se asigna - //el ámbito a la calle de la que esté a la derecha + //el ámbito a la calle de la que esté a la derecha //recorre el array de info nw for(i=0;in_amb*KK;i++) { @@ -1698,7 +1735,7 @@ BOOL Colv_limp_thr::replica_doble_sent(Info_inw_dmin *inww_ord) //le pone a la calle original que es solo FT olv_limp->iaso[refnw].flgs |= OLV_LIMP_FLG_CIRC_FT; - //Añade la info aso de la copia + //Añade la info aso de la copia info_aux.reset(); info_aux.flgs=OLV_LIMP_FLG_NW | OLV_LIMP_FLG_NW_REP | OLV_LIMP_FLG_CIRC_TF; info_aux.refe=ientcp.entity()->ref; @@ -1709,18 +1746,18 @@ BOOL Colv_limp_thr::replica_doble_sent(Info_inw_dmin *inww_ord) break; strcpy(info_aux.inf_n.nomb,olv_limp->iaso[refnw].inf_n.nomb); info_aux.refe2=refnw; - //añade la info + //añade la info olv_limp->iaso[info_aux.refe]=info_aux; ////////////////////////////////////////////// - //busca los ámbitos apuntados a ese nw, los que están a la izquiera les reapunta + //busca los ámbitos apuntados a ese nw, los que están a la izquiera les reapunta iaux=i; while((iauxn_amb*KK) && (inww_ord[iaux].refnw==refnw)) { if(!(olv_limp->iaso[inww_ord[iaux].refamb].flgs & OLV_LIMP_FLG_DER)) { - inww_ord[iaux].refnw=info_aux.refe;//el lineal que acaba de añadir - //reapunta también el original + inww_ord[iaux].refnw=info_aux.refe;//el lineal que acaba de añadir + //reapunta también el original olv_limp->inww_amb[(int)inww_ord[iaux].alpha].refnw=info_aux.refe; ///////////////////////////// olv_limp->iaso[inww_ord[iaux].refamb].flgs |= OLV_LIMP_FLG_DER; @@ -1736,12 +1773,41 @@ BOOL Colv_limp_thr::replica_doble_sent(Info_inw_dmin *inww_ord) return TRUE; } +BOOL Colv_limp_thr::corrije_conjunciones_nw() +{ + olvlog(LOG_TODO, "olv_limp_t", "revisando conjunciones de NW"); + pon_mi_msg("Comprobando conjunciones de la NW"); + CartoBaseTopologyManager topoMan; + bool res = topoMan.revisaConjunciones(&olv_limp->carto, olv_limp->n_amb, &olv_limp->cartoAux, n_subthr); + if (!res) + pon_mi_msg("Error al comprobar topologia: %s", topoMan.error); + //alade la info asociada + std::map::iterator elem; + for (elem = topoMan.referencias.begin(); elem != topoMan.referencias.end(); ++elem) { + Info_aso2 niaso; + Info_aso2 oldiaso = olv_limp->iaso[elem->second]; + niaso = oldiaso; + niaso.refe = elem->first; + if (oldiaso.inf_n.nomb) + { + int n = strlen(oldiaso.inf_n.nomb) + 1; + niaso.inf_n.nomb = (char*)malloc(n * sizeof(char)); + strcpy(niaso.inf_n.nomb, oldiaso.inf_n.nomb); + } + olv_limp->iaso[elem->first] = niaso; + niaso.inf_n.nomb = NULL; + } + char straux[256]; + sprintf(straux, "%s\\nw_ult.shp", olv_limp->olv->paths.path_temp); + //olv_limp->carto.linesExportShp(straux); + return res; +} BOOL Colv_limp_thr::corrije_topo_nw() { olvlog(LOG_TODO, "olv_limp_t", "revisando topologia de NW"); pon_mi_msg("Comprobando Topologia de la NW"); CartoBaseTopologyManager topoMan; - bool res =topoMan.revisaTopologia(&olv_limp->carto, n_subthr); + bool res =topoMan.revisaTopologia(&olv_limp->carto, olv_limp->n_amb, n_subthr); if(!res) pon_mi_msg("Error al comprobar topologia: %s", topoMan.error); //alade la info asociada @@ -1764,8 +1830,8 @@ BOOL Colv_limp_thr::corrije_topo_nw() } //************************************************************************************* /** - * Une la red navegable y los ámbitos - * 'soloi' es para debug, indica si se quiere realizar la unión de un único ámbito pasado en soloi + * Une la red navegable y los ámbitos + * 'soloi' es para debug, indica si se quiere realizar la unión de un único ámbito pasado en soloi */ BOOL Colv_limp_thr::une_amb_nw(int soloi) { @@ -1784,7 +1850,7 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) modo_ejes=TRUE; } ////////////////// - //coge el factor del tipo de ámbito, 1 si es puntual, 2 si es lineal + //coge el factor del tipo de ámbito, 1 si es puntual, 2 si es lineal KK=olv_limp->tipo_ambit; ////////////////// @@ -1806,7 +1872,7 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) } if(!olv_limp->inww_amb) { - pon_mi_msg("Error, sin memoria para matriz de índices\nde ámbitos a carreteras"); + pon_mi_msg("Error, sin memoria para matriz de índices\nde ámbitos a carreteras"); return FALSE; } //rellena todos a no def @@ -1815,38 +1881,38 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) olv_limp->inww_amb[i].reset(i%olv_limp->n_amb); } /////////////////// - olvlog(LOG_TODO,"olv_limp_t","Uniendo ámbitos a NW"); + olvlog(LOG_TODO,"olv_limp_t","Uniendo ámbitos a NW"); pon_mi_progre(OLV_TAREA_UNE_NW_AMB, 0); pon_mi_msg(""); err_str[0]=0; - //Bucle por ámbito + //Bucle por ámbito for(i=0;in_amb && !pirate; i++) { if((soloi>-1) && (soloin_amb) && (i!=soloi)) - continue;//para debug, si soloi apunta al ámbito que queremos calcular solo + continue;//para debug, si soloi apunta al ámbito que queremos calcular solo iamb = olv_limp->carto.getEntity(i); refamb=iamb.entity()->ref; if(olv_limp->iaso[refamb].flgs & OLV_LIMP_FLG_AMB_NO) continue; - //rellena en inww_amb el inw y su info de la carretera del nw élegida como - //más cercana al ámbito + //rellena en inww_amb el inw y su info de la carretera del nw élegida como + //más cercana al ámbito if(modo_ejes) busca_inw_dmin_ejes(i); else busca_inw_dmin(i); //////////////////////////////////////////// - //comprueba en todos los ámbitos si va andando, si están asignados a una carretera muy lejos - //y tienen un ámbito más cerca, les asigna ese (excepto en el caso ejes) + //comprueba en todos los ámbitos si va andando, si están asignados a una carretera muy lejos + //y tienen un ámbito más cerca, les asigna ese (excepto en el caso ejes) if(comp_lejos) comprueba_amb_lejos(i); if((i%100==0) ||(i==(olv_limp->n_amb-1))) { - olvlog(LOG_TODO,"olv_limp_t","Uniendo ámbitos a NW, %ld de %ld",i+1,olv_limp->n_amb); + olvlog(LOG_TODO,"olv_limp_t","Uniendo ámbitos a NW, %ld de %ld",i+1,olv_limp->n_amb); //avisa de progreso pon_mi_progre(OLV_TAREA_UNE_NW_AMB, (int) ((OliviaDef::GeneralDef::ProgrMax* (i+1)/olv_limp->n_amb)*((olv_limp->tipo_ambit==OLV_AMB_LIN ? 0.5 : 1)))); @@ -1855,27 +1921,27 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) //cuida si ha salido antes por falta de memo if(in_amb) { - pon_mi_msg("Error en la unión de ámbitos a red navegable"); + pon_mi_msg("Error en la unión de ámbitos a red navegable"); return FALSE; } - //Bucle por ámbito + //Bucle por ámbito for(i=0;in_amb && !pirate; i++) { if((soloi>-1) && (soloin_amb) && (i!=soloi)) - continue;//para debug, si soloi apunta al ámbito que queremos calcular solo + continue;//para debug, si soloi apunta al ámbito que queremos calcular solo iamb = olv_limp->carto.getEntity(i); refamb=iamb.entity()->ref; if(olv_limp->iaso[refamb].flgs & OLV_LIMP_FLG_AMB_NO) continue; - //Añade los segmentos a clase NW_union + //Añade los segmentos a clase NW_union add_uniones_obj(i); } //cuida si ha salido antes por falta de memo if(in_amb) { - pon_mi_msg("Error en la unión de ámbitos a red navegable"); + pon_mi_msg("Error en la unión de ámbitos a red navegable"); return FALSE; } @@ -1883,7 +1949,7 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) comprueba_aislados(olv_limp->inww_amb); ///////////////////////////////////////////////////// - //si hay algún ámbito asignado a una carretera de prohibido circular + //si hay algún ámbito asignado a una carretera de prohibido circular //se le quita el flag a la carretera if(olv_limp->res_circ!=OLV_RES_NO) { @@ -1909,8 +1975,8 @@ BOOL Colv_limp_thr::une_amb_nw(int soloi) } //************************************************************************************* /** - * Como se ha podido unir unos ámbitos a otros, revisa que no se hayan unido sólo entre sí - * y no a ninguna carretera, en ese caso estarían aislados. Lo revisa para, en esos casos, + * Como se ha podido unir unos ámbitos a otros, revisa que no se hayan unido sólo entre sí + * y no a ninguna carretera, en ese caso estarían aislados. Lo revisa para, en esos casos, * forzar a que apunte alguno a una carretera */ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) @@ -1939,7 +2005,7 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) memset(ambs_cola,0,olv_limp->n_amb*sizeof(int)); ncola=0; - //bucle para cada ámbito + //bucle para cada ámbito for(i=0;in_amb && !pirate; i++) { if(ambs_flgs[i] & FLG_VISTO) @@ -1955,7 +2021,7 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) while (ncola) { - //saca ámbito de la cola + //saca ámbito de la cola ncola--; iamb=ambs_cola[ncola]; @@ -1967,7 +2033,7 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) { if(!(olv_limp->iaso[inww[iamb+k*olv_limp->n_amb].refnw].flgs & OLV_LIMP_FLG_NW)) { - //lo mete en la cola si su extremo es un ámbito + //lo mete en la cola si su extremo es un ámbito //no visto ni temporal if(ambs_flgs[inww[iamb+k*olv_limp->n_amb].refnw] & (FLG_TEMP | FLG_VISTO)) continue; @@ -1993,7 +2059,7 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) for(k=0;kn_amb].inw_old) - continue;//no debería + continue;//no debería if(inww[j+k*olv_limp->n_amb].inw_old->dminn_amb; @@ -2008,7 +2074,7 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) free(inww[iambmin].inw_old); inww[iambmin].inw_old=NULL; - //añade el segmento de unión + //añade el segmento de unión add_uniones_obj(iambmin%olv_limp->n_amb); } } @@ -2030,8 +2096,8 @@ void Colv_limp_thr::comprueba_aislados(Info_inw_dmin *inww) //************************************************************************************* /** * Comprueba en 'inww' si 'daux' es menor que las almacenadas. - * Devuelve la posición del array inww donde tiene que ir o -1 si no es menor - * y vacía dicha posición, moviendo las demás, para que el siguiente guarde ahí lo que toca + * Devuelve la posición del array inww donde tiene que ir o -1 si no es menor + * y vacía dicha posición, moviendo las demás, para que el siguiente guarde ahí lo que toca */ int Colv_limp_thr::is_dmin(double daux, Info_inw_dmin *inww) { @@ -2058,7 +2124,7 @@ int Colv_limp_thr::is_dmin(double daux, Info_inw_dmin *inww) } //************************************************************************************* /** - * Devuelve la ent de la nw que esté más cerca del ámbito iamb, a la que se le asigna + * Devuelve la ent de la nw que esté más cerca del ámbito iamb, a la que se le asigna */ BOOL Colv_limp_thr::busca_inw_dmin_ejes(int i_amb) { @@ -2070,13 +2136,13 @@ BOOL Colv_limp_thr::busca_inw_dmin_ejes(int i_amb) npts=ientamb.getNumberPtos(); //////////////////////////////////////////////////////////////////////// //Bucle por cada carretera de la nw - //empiezan donde acaban los ámbitos, y terminan en namb+nnw + //empiezan donde acaban los ámbitos, y terminan en namb+nnw for(inw=olv_limp->n_amb; inwn_amb+olv_limp->n_nw && !pirate; inw++) { ientnw=olv_limp->carto.getEntity(inw); refenw=ientnw.entity()->ref; if(!(olv_limp->iaso[refenw].flgs & OLV_LIMP_FLG_NW)) - continue; //no debería, pero por si acaso + continue; //no debería, pero por si acaso if(olv_limp->iaso[refenw].oid==olv_limp->iaso[refamb].oid) break; @@ -2095,7 +2161,7 @@ BOOL Colv_limp_thr::busca_inw_dmin_ejes(int i_amb) olv_limp->inww_amb[z].ip=k*(npts-2); olv_limp->inww_amb[z].lamb=(float)k; memcpy(olv_limp->inww_amb[z].pt,ientamb.getPto(k*(npts-1)),3*sizeof(double)); - //copia info de qué amb y qué punto ini o fin es, para poder recuperar cuando está ordenador por inw + //copia info de qué amb y qué punto ini o fin es, para poder recuperar cuando está ordenador por inw olv_limp->inww_amb[z].refamb=refamb; olv_limp->inww_amb[z].alpha=(float)(z); } @@ -2103,9 +2169,9 @@ BOOL Colv_limp_thr::busca_inw_dmin_ejes(int i_amb) } //************************************************************************************* /** - * Devuelve la distancia de un ámbito 'i_amb' a la carretera más cercana, + * Devuelve la distancia de un ámbito 'i_amb' a la carretera más cercana, * y rellena la info de dicha carretera en inww_amb. - * KK indica el tipo de ámbito, si es 1 es puntual, sólo se calcula una distancia a la carretera, + * KK indica el tipo de ámbito, si es 1 es puntual, sólo se calcula una distancia a la carretera, * si es 2, es lineal, se calculan la distancia al extremo inicial y al final */ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) @@ -2115,11 +2181,11 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) double lon, disptos, daux, alphamin[2], desv,lamb; int i, inw, refenw,k,i_inww,j,jmin[2],i_nw,KK,refamb,ip; CartoBaseInfoEntity ientnw, ientamb; - double pt_ang[2][3], *p0, *p1, prod, mod1, mod2; //almacena dos puntos para calcular el vector con el que forma el ángulo el ámbito + double pt_ang[2][3], *p0, *p1, prod, mod1, mod2; //almacena dos puntos para calcular el vector con el que forma el ángulo el ámbito //////////////////////////// - //esto se hace porque se sabe que son siempre 2 puntos, y así no se pide memoria - //dinámica en el garray + //esto se hace porque se sabe que son siempre 2 puntos, y así no se pide memoria + //dinámica en el garray ptos_aux.pts.n = 2; ptos_aux.pts.ptr =pt_ang; //////////////////////////// @@ -2129,13 +2195,13 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) - //inicializa array local para almacenamiento de las tres carreteras más cercanas + //inicializa array local para almacenamiento de las tres carreteras más cercanas memset(inww,0,sizeof(Info_inw_dmin)*OLV_LIMP_N_DMIN_NW*2); for(i=0; in_amb; inwn_amb+olv_limp->n_nw && !pirate; inw++) { ientnw=olv_limp->carto.getEntity(inw); refenw=ientnw.entity()->ref; if(!(olv_limp->iaso[refenw].flgs & OLV_LIMP_FLG_NW)) - continue; //no debería, pero por si acaso + continue; //no debería, pero por si acaso //lo hace para punto inicial y final si es lineal, o solo una vez si es puntual for(k=0; krevisa_elev); //coge la dis media para quedarse con la min ientnw.DisPtoLine(prime_ptos.getPto(0),&ip, &lamb, olv_limp->revisa_elev); //coge el punto donde se da la min } @@ -2184,7 +2250,7 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) i_inww=is_dmin(daux,&inww[k*OLV_LIMP_N_DMIN_NW]); if(i_inww>=0) { - //Dist ptos-recta. Si dist mayor que la mínima guardada, descarta. + //Dist ptos-recta. Si dist mayor que la mínima guardada, descarta. // Si todas dist similares y menores que una dada, se guarda //inw->linea de la nw inww[i_inww+k*OLV_LIMP_N_DMIN_NW].dmin=(float)daux; @@ -2197,7 +2263,7 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) } } //////////////////////////////////////////////////////////////////////// - //coger de los tres de inww el que del punto ip de nw al extremo de amb forme el ángulo + //coger de los tres de inww el que del punto ip de nw al extremo de amb forme el ángulo //cuya diferencia con pi/2 sea menor (en el caso lineal) //y ponerlo en inww_amb[i-olv_limp->n_ini_amb] jmin[0]=jmin[1]=0; @@ -2214,23 +2280,23 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) ientnw=olv_limp->carto.getRef(i_nw); - //calcula el punto del inw donde se da el mínimo + //calcula el punto del inw donde se da el mínimo p0=ientnw.getPto(inww[j+k*OLV_LIMP_N_DMIN_NW].ip); p1=ientnw.getPto(inww[j+k*OLV_LIMP_N_DMIN_NW].ip+1); inww[j+k*OLV_LIMP_N_DMIN_NW].pt[2]=0; inww[j+k*OLV_LIMP_N_DMIN_NW].pt[0]=p0[0]+(p1[0]-p0[0])*inww[j+k*OLV_LIMP_N_DMIN_NW].lamb; inww[j+k*OLV_LIMP_N_DMIN_NW].pt[1]=p0[1]+(p1[1]-p0[1])*inww[j+k*OLV_LIMP_N_DMIN_NW].lamb; - //solo para tipo lineal, elige el de distancia menor y que el ángulo que forma el ámbito con - //el punto más cercano de la nw sea el más ortogonal + //solo para tipo lineal, elige el de distancia menor y que el ángulo que forma el ámbito con + //el punto más cercano de la nw sea el más ortogonal if(KK==OLV_AMB_LIN) { if(k==0) prime_ptos = prime_ptos_i; else prime_ptos = prime_ptos_f; - //el ángulo se calcula entre el extremo del ámbito con el vector que forman dicho extremo del - //ámbito con el punto del inw donde se da el mínimo + //el ángulo se calcula entre el extremo del ámbito con el vector que forman dicho extremo del + //ámbito con el punto del inw donde se da el mínimo pt_ang[0][0] = prime_ptos.getPto(0)[0]; pt_ang[0][1] = prime_ptos.getPto(0)[1]; pt_ang[0][2] = prime_ptos.getPto(0)[2]; @@ -2250,9 +2316,9 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) if(KK==OLV_AMB_LIN) { - //únicamente si el segundo más cercano (el de la pos '1') tiene alpha menor, y una distancia no mucho mayor + //únicamente si el segundo más cercano (el de la pos '1') tiene alpha menor, y una distancia no mucho mayor //lo coge, - //si no, se queda el más cercano + //si no, se queda el más cercano for(k=0; kres_circ!=OLV_RES_NO) { - //si hay restricciones de circulación, y se va a coger como dmin una carretera peatonal, coge la siguiente de dmin + //si hay restricciones de circulación, y se va a coger como dmin una carretera peatonal, coge la siguiente de dmin for(k=0; kiaso[inww[k*OLV_LIMP_N_DMIN_NW].refnw].flgs & OLV_LIMP_FLG_CIRC_NONE) && @@ -2276,12 +2342,12 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb) } } - //copia el mínimo que ha encontrado + //copia el mínimo que ha encontrado //para el punto inicial y final, o solo una vez si es puntual for(k=0; kinww_amb[i_amb+k*olv_limp->n_amb],&inww[jmin[k]+k*OLV_LIMP_N_DMIN_NW],sizeof(Info_inw_dmin)); - //copia info de qué amb y qué punto ini o fin es, para poder recuperar cuando está ordenador por inw + //copia info de qué amb y qué punto ini o fin es, para poder recuperar cuando está ordenador por inw olv_limp->inww_amb[i_amb+k*olv_limp->n_amb].refamb=refamb; olv_limp->inww_amb[i_amb+k*olv_limp->n_amb].alpha=(float)(i_amb+k*olv_limp->n_amb); } @@ -2292,9 +2358,9 @@ fin: } //************************************************************************************* /** - * Dado un ámbito 'i_amb' (ya relativo al n_ini_amb) de un total de n_amb, + * Dado un ámbito 'i_amb' (ya relativo al n_ini_amb) de un total de n_amb, * de 'npt_amb' puntos almacenados en 'pt_amb', - * añade al 'ob' las uniones del mismo con la carretera 'pt_nw' + * añade al 'ob' las uniones del mismo con la carretera 'pt_nw' * de los dos extremos si es lineal o uno si es puntual, indicado por 'KK' */ void Colv_limp_thr::add_uniones_obj(int i_amb) @@ -2309,15 +2375,15 @@ void Colv_limp_thr::add_uniones_obj(int i_amb) Info_inw_dmin *inww; //////////////////////////// - //esto se hace porque se sabe que son siempre 2 puntos, y así no se pide memoria - //dinámica en el garray + //esto se hace porque se sabe que son siempre 2 puntos, y así no se pide memoria + //dinámica en el garray ptos_aux.pts.n = 2; ptos_aux.pts.ptr = ptos; //////////////////////////// ientamb=olv_limp->carto.getEntity(i_amb); refamb=ientamb.entity()->ref; KK=olv_limp->tipo_ambit; - nptos=2; //siempre añade segmentos + nptos=2; //siempre añade segmentos //poner el flag de segmento, si es eje, refe2... si es lin o pun, si es fin... if(KK==OLV_AMB_LIN) @@ -2334,18 +2400,18 @@ void Colv_limp_thr::add_uniones_obj(int i_amb) ya=TRUE; do { - //apunta al nw más cercano del ámbito actual que se acaba de encontrar + //apunta al nw más cercano del ámbito actual que se acaba de encontrar refnw=inww->refnw; if(refnw<0 || refnw>=(olv_limp->n_nw+olv_limp->n_amb) || (refnw==i_amb)) //por si acaso continue; ientnw = olv_limp->carto.getRef(refnw); - //apunta el array de puntos al ámbito + //apunta el array de puntos al ámbito if(KK==OLV_AMB_LIN)//para tipo lineal, obtiene los primeros puntos de los dos extremos { npt_amb = ientamb.getNumberPtos(); } - else if(KK==OLV_AMB_PUN) //para tipo puntual, es un único punto + else if(KK==OLV_AMB_PUN) //para tipo puntual, es un único punto { npt_amb = 1; } @@ -2372,15 +2438,15 @@ void Colv_limp_thr::add_uniones_obj(int i_amb) ff|=OLV_LIMP_FLG_FIN; //rellena el segmento - //el primer punto es el de la carretera más cercano al ámbito + //el primer punto es el de la carretera más cercano al ámbito memcpy(ptos[0],inww->pt,3*sizeof(double)); - //el segundo punto es el propio del ámbito (inicio y final si es lineal) + //el segundo punto es el propio del ámbito (inicio y final si es lineal) memcpy(ptos[1],ientamb.getPto((npt_amb-1)*k),3*sizeof(double)); - //lo añade al carto + //lo añade al carto olv_limp->carto.add(ptos_aux); ientseg=olv_limp->carto.getEntity(olv_limp->carto.getNumberEntities()-1); - //Añade la info aso + //Añade la info aso info_aux.reset(); info_aux.flgs=ff; info_aux.refe=ientseg.entity()->ref; @@ -2391,7 +2457,7 @@ void Colv_limp_thr::add_uniones_obj(int i_amb) { if(inww->inw_old->dmininw_old;//añade las uniones a la nw y a los cercanos siempre! + inww=inww->inw_old;//añade las uniones a la nw y a los cercanos siempre! ya=FALSE; } else @@ -2405,22 +2471,22 @@ void Colv_limp_thr::add_uniones_obj(int i_amb) } //************************************************************************************* /** - * Comprueba si el segmento corta a otro ámbito (en tratamientos lineales) - * si lo corta, apunta el primer punto del segmento al punto extremo más cercano - * de dicho ámbito al ámbito ppal + * Comprueba si el segmento corta a otro ámbito (en tratamientos lineales) + * si lo corta, apunta el primer punto del segmento al punto extremo más cercano + * de dicho ámbito al ámbito ppal */ void Colv_limp_thr::compr_cortes_amb() { - olvlog(LOG_TODO,"olv_limp_t","Comprobando cortes entre uniones y ámbitos"); + olvlog(LOG_TODO,"olv_limp_t","Comprobando cortes entre uniones y ámbitos"); pon_mi_progre(OLV_TAREA_COST_AMB, 0); - pon_mi_msg("Comprobando cortes entre uniones y ámbitos"); + pon_mi_msg("Comprobando cortes entre uniones y ámbitos"); err_str[0]=0; //lanza los threads lanza_subthrs(OLV_LIMP_EV_COMPCORT_SUB,1); } //************************************************************************************* /** - * Función de los subthreads + * Función de los subthreads */ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) { @@ -2434,7 +2500,7 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) double dist,lamb,*pt_amb2,lambs,distseg; //////////////// - pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso KK=olv_limp->tipo_ambit; na_desp = (int)ceil(1.0*(olv_limp->n_amb)/n_subthr); na_ini= min(ithr*na_desp, olv_limp->n_amb); @@ -2445,7 +2511,7 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) seg = GetTickCount(); ///////////////////////////////////// - //Bucle por cada ámbito de los que le tocan a este thread + //Bucle por cada ámbito de los que le tocan a este thread ///////////////////////////////////// na=na_ini; nent=olv_limp->carto.getNumberEntities(); @@ -2455,8 +2521,8 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) { ient_na=olv_limp->carto.get(na); ref_na=ient_na.entity()->ref; - //revisa si la unión de este ámbito con la carretera interseca con otro ámbito - for(isg=olv_limp->n_amb+olv_limp->n_nw;isgn_amb+olv_limp->n_nw;isgcarto.get(isg); if(ient_i.entity()->type!=CartoBaseTypes::Line) @@ -2468,8 +2534,8 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) (olv_limp->iaso[ref_i].flgs & OLV_LIMP_FLG_SEG_AMB)) continue; - //ha encontrado el segmento inicial del ámbito, comprueba si corta con algún otro ámbito - //recorre de nuevo los ámbitos, esta vez todos + //ha encontrado el segmento inicial del ámbito, comprueba si corta con algún otro ámbito + //recorre de nuevo los ámbitos, esta vez todos for(iamb2=0;iamb2n_amb;iamb2++) { if(iamb2==na) @@ -2484,8 +2550,8 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) continue;//no intersecan //intersecan - //apunta el primer ámbito al extremo más cercano del otro ámbito - //mira cuál es el extremo más cercano + //apunta el primer ámbito al extremo más cercano del otro ámbito + //mira cuál es el extremo más cercano npt_amb2 = ient_ia.getNumberPtos(); //pt_amb2=ient_ia.PtInLine(ip, lamb,pt_aux); //renombra pt_amb2 al extremo al que esta mas cerca @@ -2500,12 +2566,12 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr) h=0; } pt_amb2=ient_ia.getPto((npt_amb2-1)*h); - //calcula distancia del ámbito a ientamb2 - 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 + //calcula distancia del ámbito a ientamb2 + 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 && distencola(OLV_LIMP_EV_SUBTHR_PROG,&pp,FALSE); } } - olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Fin comprobación cortes entre uniones y ambs, %.3f seg", ithr, 1.0*(GetTickCount()-seg)/1000); + olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Fin comprobación cortes entre uniones y ambs, %.3f seg", ithr, 1.0*(GetTickCount()-seg)/1000); thr_padre->encola(OLV_LIMP_EV_COMPCORT_FIN,NULL,FALSE); } //************************************************************************************* /** - * Función final + * Función final */ BOOL Colv_limp_thr::compr_cortes_amb_sub_fin() { @@ -2539,8 +2605,8 @@ BOOL Colv_limp_thr::compr_cortes_amb_sub_fin() } //************************************************************************************* /** - * Comprueba, si es ámbito, si la carretera está muy lejos. - * Si es que sí, o bien busca otro ámbito más cercano, o lo deja vacío + * Comprueba, si es ámbito, si la carretera está muy lejos. + * Si es que sí, o bien busca otro ámbito más cercano, o lo deja vacío */ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) { @@ -2561,7 +2627,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) //////////////////////// KK=olv_limp->tipo_ambit; - dmax=OLV_DIST_MAX_AMB_NW;// m de separación max entre peatonal y calle + dmax=OLV_DIST_MAX_AMB_NW;// m de separación max entre peatonal y calle /////////////////////// ientamb=olv_limp->carto.getEntity(i_amb); refamb=ientamb.entity()->ref; @@ -2588,8 +2654,8 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) // continue; //Distancia muy grande - //Recorre el resto de ámbitos buscando uno más cercana - //Bucle por ámbito + //Recorre el resto de ámbitos buscando uno más cercana + //Bucle por ámbito dmin=MAYUSCULO; for(i=0;in_amb; i++) { @@ -2607,7 +2673,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) npt_amb2 = ientamb2.getNumberPtos(); } - else if(KK==OLV_AMB_PUN) //para tipo puntual, es un único punto + else if(KK==OLV_AMB_PUN) //para tipo puntual, es un único punto { npt_amb2 = 1; } @@ -2669,21 +2735,21 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) if((dmininww_amb[iaux+is_fin*olv_limp->n_amb].refnw==i_amb) && olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old) { - //si sí, comprueba cuál de los dos tiene la nw a menos distancia - //ese lo apunta a la nw y el otro al ámbito cercano + //si sí, comprueba cuál de los dos tiene la nw a menos distancia + //ese lo apunta a la nw y el otro al ámbito cercano if(olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old->dmin< olv_limp->inww_amb[i_amb+k*olv_limp->n_amb].dmin) { if(olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old->dmininww_amb[iaux+is_fin*olv_limp->n_amb].inw_old; memcpy(&olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb],inwaux,sizeof(Info_inw_dmin)); @@ -2691,13 +2757,13 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) free(olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old); olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old=NULL; } - //si es mayor que dmax, el anterior se queda como está, y este pone de ppal al ámbito y no guarda old - //indica que no guarde de este el old porque solo va a coger de ppal al ámbito + //si es mayor que dmax, el anterior se queda como está, y este pone de ppal al ámbito y no guarda old + //indica que no guarde de este el old porque solo va a coger de ppal al ámbito guarda_nw_old=FALSE; } else { - //es éste el que está más cerca + //es éste el que está más cerca //al otro le borra el old free(olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old); olv_limp->inww_amb[iaux+is_fin*olv_limp->n_amb].inw_old=NULL; @@ -2735,7 +2801,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) } else if((dmin>longmax) && !modo_solouno) { - //si está todavía más lejos, lo apunta a su principio + //si está todavía más lejos, lo apunta a su principio lejos|=1<inww_amb[i_amb].refnw = refamb; olv_limp->inww_amb[i_amb].ip =0; memcpy(olv_limp->inww_amb[i_amb].pt,ientamb.getPto(olv_limp->inww_amb[i_amb].ip),3*sizeof(double)); } else if(lejos & (1<<0)) { - //si ha dejado sólo el segundo + //si ha dejado sólo el segundo olv_limp->inww_amb[i_amb+olv_limp->n_amb].refnw = refamb; olv_limp->inww_amb[i_amb+olv_limp->n_amb].ip = npt_amb-1; memcpy(olv_limp->inww_amb[i_amb+olv_limp->n_amb].pt,ientamb.getPto(olv_limp->inww_amb[i_amb+olv_limp->n_amb].ip),3*sizeof(double)); @@ -2759,7 +2825,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb ) } //************************************************************************************* /** - * Comprueba si hay ámbitos a un lado que se supone deberían estar al otro + * Comprueba si hay ámbitos a un lado que se supone deberían estar al otro */ BOOL Colv_limp_thr::comprueba_latelaridad() { @@ -2781,12 +2847,12 @@ BOOL Colv_limp_thr::comprueba_latelaridad() msg_[0]=0; ///////////////////LATERALIDAD - //recorres inww_amb_aux, que está ordenado por inw + //recorres inww_amb_aux, que está ordenado por inw //solo en puntuales //si res_cirobjt)[inww_amb_aux[i].inw].ia].flgs & OLV_LIMP_FLG_CIRC_FT //fronto mismo sentido que lineal + //si calle un único sentido: ias[(*ob->objt)[inww_amb_aux[i].inw].ia].flgs & OLV_LIMP_FLG_CIRC_FT //fronto mismo sentido que lineal //si lateral==derecha y amb a la izquierda, descarta - //amb -> ias[inww_amb_aux[ì].iamb].flgs & OLV_LIMP_FLG_DER + //amb -> ias[inww_amb_aux[ì].iamb].flgs & OLV_LIMP_FLG_DER //o si lateral==izda y amb a la derecga, descarta for(int ia=0; ian_amb; ia++) @@ -2810,13 +2876,13 @@ BOOL Colv_limp_thr::comprueba_latelaridad() continue; } - //lee el objectid del ámbito + //lee el objectid del ámbito id=olv_limp->iaso[olv_limp->inww_amb[ia].refamb].oid; - olvlog(LOG_TODO,"olv_limp_t","Ámbito %ld lateralidad errónea",olv_limp->iaso[olv_limp->inww_amb[ia].refamb].oid); + olvlog(LOG_TODO,"olv_limp_t","Ãmbito %ld lateralidad errónea",olv_limp->iaso[olv_limp->inww_amb[ia].refamb].oid); //imprime if(msg_[0]==0) - sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Encontrados contenedores con lateralidad errónea: "); + sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Encontrados contenedores con lateralidad errónea: "); if(sigue_msg) sprintf_s(msg_,OLV_MAX_MSG_PROCE,"%s %ld,",msg_,id); if(sigue_msg && strlen(msg_)+10>=OLV_MAX_MSG_PROCE) @@ -2834,7 +2900,7 @@ BOOL Colv_limp_thr::comprueba_latelaridad() } //************************************************************************************* /** - * Realiza el ánalisis topológico a la red navegable junto con los ámbitos y los segmentos + * Realiza el ánalisis topológico a la red navegable junto con los ámbitos y los segmentos * que les unen, para incluir los mismos en la red navegable */ BOOL Colv_limp_thr::topo_nw() @@ -2856,28 +2922,28 @@ BOOL Colv_limp_thr::topo_nw() ///////////////// ///////////////// - olvlog(LOG_TODO,"olv_limp_t","Generando topología con los segmentos de unión"); + olvlog(LOG_TODO,"olv_limp_t","Generando topología con los segmentos de unión"); pon_mi_progre(OLV_TAREA_TOPO_NW, 0); pon_mi_msg(""); err_str[0]=0; int ent1=olv_limp->carto.getNumberEntities(); - //inicializa la matriz auxiliar para ordenación + //inicializa la matriz auxiliar para ordenación inww_amb_aux = (Info_inw_dmin *)malloc(olv_limp->n_amb*KK*sizeof(Info_inw_dmin)); if(!inww_amb_aux) { - pon_mi_msg("Error, sin memoria para matriz de índices\nde ámbitos a carreteras"); + pon_mi_msg("Error, sin memoria para matriz de índices\nde ámbitos a carreteras"); return FALSE; } memcpy(inww_amb_aux,olv_limp->inww_amb,olv_limp->n_amb*KK*sizeof(Info_inw_dmin)); ////////////////////////////////////////////////// - //ordena la matriz de info de inw, va de punto más cercano - //al inicio del inw inicial al más lejano, y aumentando en inw + //ordena la matriz de info de inw, va de punto más cercano + //al inicio del inw inicial al más lejano, y aumentando en inw //dentro del mismo inw, ordena por ip y a igual ip, por lamb qsort(inww_amb_aux,olv_limp->n_amb*KK,sizeof(Info_inw_dmin),Colv_limp_thr::compara_inww_amb); - olvlog(LOG_TODO,"olv_limp_t","Generando topología: Matriz de info de inw dmin ordenada"); + olvlog(LOG_TODO,"olv_limp_t","Generando topología: Matriz de info de inw dmin ordenada"); ////////////////////// //mira a ver si tiene que replicar calles de doble sentido @@ -2908,7 +2974,7 @@ BOOL Colv_limp_thr::topo_nw() ia++; continue; } - if(!(olv_limp->iaso[refnw].flgs & OLV_LIMP_FLG_NW)) //es que se ha reapuntado a otro ámbito por ser peatonal lejana + if(!(olv_limp->iaso[refnw].flgs & OLV_LIMP_FLG_NW)) //es que se ha reapuntado a otro ámbito por ser peatonal lejana { ia++; continue; @@ -2926,7 +2992,7 @@ BOOL Colv_limp_thr::topo_nw() nt++; } - if(nt<2) //tiene que haber siempre mínimo 2 tramos, ya que en todos los inw de este array hay algún ámbito asignado + if(nt<2) //tiene que haber siempre mínimo 2 tramos, ya que en todos los inw de este array hay algún ámbito asignado { olvlog(LOG_TODO,"olv_limp_t","Gen. Topo. Inw %03d mal, se obtienen %ld tramos, no suficientes",refnw,nt); mal=TRUE; @@ -2946,13 +3012,13 @@ BOOL Colv_limp_thr::topo_nw() if(ia>0 && inww_amb_aux[ia-1].flgs>1) olv_limp->inww_amb[(int)inww_amb_aux[ia-1].alpha].refnw=info_aux.refe; - //recorre la carretera inwi y la parte en trozos acorde a los ámbitos - if(iat==0)//hace el primer tramo, del extremo inicial al primer ámbito + //recorre la carretera inwi y la parte en trozos acorde a los ámbitos + if(iat==0)//hace el primer tramo, del extremo inicial al primer ámbito { npt_nw_aux=inww_amb_aux[ia].ip+2; if(Colv_geom::pto_equals(ientnw.getPto(0), inww_amb_aux[ia].pt)) { - //no se hace tramo porque está unido por el extremo + //no se hace tramo porque está unido por el extremo iat++; ia++; if(nt==2) @@ -2962,24 +3028,24 @@ BOOL Colv_limp_thr::topo_nw() } continue; } - //los primeros puntos son los de la carretera hasta el ámbito + //los primeros puntos son los de la carretera hasta el ámbito for(pp=0;ppcarto.add(ptos_aux); info_aux.refe=olv_limp->carto.get(olv_limp->carto.getNumberEntities()-1).entity()->ref; if(olv_limp->iaso[refnw].inf_n.nomb) @@ -3017,7 +3083,7 @@ BOOL Colv_limp_thr::topo_nw() if((ia%100==0) || (ia==(olv_limp->n_amb*KK))) { - olvlog(LOG_TODO,"olv_limp_t","Generando topología, %ld de %ld",ia,olv_limp->n_amb*KK); + olvlog(LOG_TODO,"olv_limp_t","Generando topología, %ld de %ld",ia,olv_limp->n_amb*KK); //avisa de progreso pon_mi_progre(OLV_TAREA_TOPO_NW, (int) ((OliviaDef::GeneralDef::ProgrMax* 1.0*(ia)/(olv_limp->n_amb*KK)))); @@ -3027,7 +3093,7 @@ BOOL Colv_limp_thr::topo_nw() info_aux.inf_n.nomb = NULL; if(mal) { - pon_mi_msg("Errores en el análisis topológico"); + pon_mi_msg("Errores en el análisis topológico"); } if(mal || pirate) { @@ -3075,7 +3141,7 @@ BOOL Colv_limp_thr::topo_nw() return FALSE; } - //hace limpieza de la carto, ya que ha terminado de hacer topología o añadir cosas + //hace limpieza de la carto, ya que ha terminado de hacer topología o añadir cosas olv_limp->carto.FastClear(); //olv_limp->carto.linesExportShp("C:\\Proyectos\\Olivia\\Instal\\topo.shp"); @@ -3114,7 +3180,7 @@ int Colv_limp_thr::compara_inww_amb (const void * a, const void * b) } //************************************************************************************* /** - * Añade a la red de conjunciones en qué conjunción está la planta y la instalación + * Añade a la red de conjunciones en qué conjunción está la planta y la instalación */ BOOL Colv_limp_thr::pon_nodos_planta(double pt[3]) { @@ -3126,7 +3192,7 @@ BOOL Colv_limp_thr::pon_nodos_planta(double pt[3]) Info_aso2 info_aux; if((pt[0]==0) && (pt[1]==0)) - return TRUE;//no hay instalación, no se pone + return TRUE;//no hay instalación, no se pone //////////////////////////////////////////////////////////////////////// //Bucle por cada carretera de la nw @@ -3144,7 +3210,7 @@ BOOL Colv_limp_thr::pon_nodos_planta(double pt[3]) ientnw=olv_limp->carto.get(i); - //calcula la distancia al punto de la instalación + //calcula la distancia al punto de la instalación d = ientnw.DisPtoLine(pt,&ip,&lamb); if(dcarto.getRef(inww.refnw); - //calcula el punto del inw donde se da el mínimo + //calcula el punto del inw donde se da el mínimo pt_ip=ientnw.getPto(inww.ip); pt_ip1=ientnw.getPto(inww.ip+1); @@ -3181,7 +3247,7 @@ BOOL Colv_limp_thr::pon_nodos_planta(double pt[3]) if(!ientnw.DivLine(&lines[0],&lines[1],inww.ip,inww.lamb)) return FALSE; - //añade los tramos, les pone la misma info asociada que la carretera original + //añade los tramos, les pone la misma info asociada que la carretera original info_aux.reset(); memcpy(&info_aux,&olv_limp->iaso[inww.refnw],sizeof(Info_aso2)); @@ -3202,13 +3268,13 @@ BOOL Colv_limp_thr::pon_nodos_planta(double pt[3]) } olv_limp->carto.removeRef(inww.refnw); - //olv_limp->carto.clear(); //se hace después + //olv_limp->carto.clear(); //se hace después return TRUE; } //************************************************************************************* /** - * Apunta en qué nodos está la planta y la instalación + * Apunta en qué nodos está la planta y la instalación */ BOOL Colv_limp_thr::busca_conjs_planta(double pt[3], int *nod) { @@ -3216,11 +3282,11 @@ BOOL Colv_limp_thr::busca_conjs_planta(double pt[3], int *nod) BOOL mal=FALSE; if((pt[0]==0) && (pt[1]==0)) - return TRUE;//no hay instalación, no se pone + return TRUE;//no hay instalación, no se pone //busca ese punto en la lista de conjunciones - //busca la conjunción en la lista - //lo hace para los dos extremos de la línea + //busca la conjunción en la lista + //lo hace para los dos extremos de la línea for(ic=0; icconjs.n;ic++) { if((Colv_geom::pto_equals(pt,olv_limp->conjs.coor[ic]))) @@ -3302,9 +3368,9 @@ BOOL Colv_limp_thr::calcula_cost_conj() pon_mi_msg("Rellenando matriz de costes entre nodos"); err_str[0]=0; - //calcula el número de nodos de la red - //que es el número de intersecciones de la red navegable, incluyendo el número de ámbitos x2 porque - //aparecen el punto del ámbito y el proyectado en la carretera más próxima (y x2 si son lineales) + //calcula el número de nodos de la red + //que es el número de intersecciones de la red navegable, incluyendo el número de ámbitos x2 porque + //aparecen el punto del ámbito y el proyectado en la carretera más próxima (y x2 si son lineales) olvlog(LOG_TODO,"olv_limp_t","Comienza a buscar conjunciones"); if(!busca_conjs()) { @@ -3333,12 +3399,12 @@ BOOL Colv_limp_thr::calcula_cost_conj() pon_mi_msg("Rellenando matriz de costes entre nodos. %ld nodos por calcular", olv_limp->conjs.n); //pide memoria para el array de distancias entre conjunciones - ///mira a ver con cuántos nvect puede calcular la matriz + ///mira a ver con cuántos nvect puede calcular la matriz CoptiMemo oo; int nvect = oo.calc_nvect_master(olv_limp->conjs.n); if(nvect<0) { - pon_mi_msg("Error, sin memoria para matriz de conjunciones en cálculo de nvect"); + pon_mi_msg("Error, sin memoria para matriz de conjunciones en cálculo de nvect"); return FALSE; } olvlog(LOG_TODO,"olv_limp_t","Se va a ejecutar con nvect=%ld de %ld",nvect,olv_limp->conjs.n); @@ -3347,7 +3413,7 @@ BOOL Colv_limp_thr::calcula_cost_conj() olv_limp->cost_conj.inicializa(olv_limp->conjs.n,n_subthr,nvect); olv_limp->tip_conj.inicializa(olv_limp->conjs.n,n_subthr,nvect); - //si solo le llega una calle a una conjunción, y es de sentido único, le pone doble sentido + //si solo le llega una calle a una conjunción, y es de sentido único, le pone doble sentido for(i=0;iconjs.n;i++) { if(olv_limp->conjs.inc[i].n==1) @@ -3418,7 +3484,7 @@ BOOL Colv_limp_thr::cuida_memo_conj(Info_conjs *conjs) } //************************************************************************************* /** - * Rellena la matriz de conjunciones entre toda la red, navegable y ámbitos + * Rellena la matriz de conjunciones entre toda la red, navegable y ámbitos * y la info de las conjunciones se rellena en 'conjs' */ BOOL Colv_limp_thr::busca_conjs() @@ -3435,11 +3501,11 @@ BOOL Colv_limp_thr::busca_conjs() modo_ejes=TRUE; //bucle por cada entidad de la carto - //si es modos de ámbitos normales, lineales o puntuales, se va de inicio a final del carto, en orden - //y se van buscando las conjs de los ámbitos, los nw, y los segmentos - //si es un modo en el que los ámbitos son ejes, se va al revés, añadiendo primero las conjunciones de - //los segmentos y la nw, y por último las de los ejes. Se hace para que en el siguiente paso, al buscar, - //aparezca primero la conjunción de la carretera, porque es de la que no se tiene constancia ic_ini/ic_fin + //si es modos de ámbitos normales, lineales o puntuales, se va de inicio a final del carto, en orden + //y se van buscando las conjs de los ámbitos, los nw, y los segmentos + //si es un modo en el que los ámbitos son ejes, se va al revés, añadiendo primero las conjunciones de + //los segmentos y la nw, y por último las de los ejes. Se hace para que en el siguiente paso, al buscar, + //aparezca primero la conjunción de la carretera, porque es de la que no se tiene constancia ic_ini/ic_fin io=0; nent=olv_limp->carto.getNumberEntities(); @@ -3484,8 +3550,8 @@ BOOL Colv_limp_thr::busca_conjs() } else { - //busca la conjunción en la lista - //lo hace para los dos extremos de la línea + //busca la conjunción en la lista + //lo hace para los dos extremos de la línea for(ic=0; icconjs.n;ic++) { if((Colv_geom::pto_equals(pto,olv_limp->conjs.coor[ic]))) @@ -3493,7 +3559,7 @@ BOOL Colv_limp_thr::busca_conjs() } if(ic==olv_limp->conjs.n) { - //no lo ha encontrado, lo añade + //no lo ha encontrado, lo añade if(!add_conj(&olv_limp->conjs,pto)) { mal=TRUE; @@ -3503,7 +3569,7 @@ BOOL Colv_limp_thr::busca_conjs() } ics[k]=ic; - //si es carretera, le pone a la conjunción que llega una al menos + //si es carretera, le pone a la conjunción que llega una al menos //if(olv_limp->iaso[refent].flgs & OLV_LIMP_FLG_NW) { if(olv_limp->conjs.inc[ic].n<0) @@ -3522,7 +3588,7 @@ BOOL Colv_limp_thr::busca_conjs() olv_limp->iaso[refent].inod[k]=ics[k]; } - //si es segmento de ámbito puntual, le pone al ámbito la conjunción + //si es segmento de ámbito puntual, le pone al ámbito la conjunción if(olv_limp->iaso[refent].flgs & OLV_LIMP_FLG_SEG_PUN) { refe2=olv_limp->iaso[refent].refe2; @@ -3554,16 +3620,16 @@ BOOL Colv_limp_thr::busca_conjs() if(olv_limp->iaso[refent].flgs & OLV_LIMP_FLG_PEAT_SEG) { - //ref1 es la réplica de la peatonal + //ref1 es la réplica de la peatonal ref1=olv_limp->iaso[refent].refe; //ref2 es la peatonal original ref2=olv_limp->iaso[refent].refe2; } else if(olv_limp->iaso[refent].flgs & OLV_LIMP_FLG_EJE_SEG) { - //ref1 es el eje original, como ámbito + //ref1 es el eje original, como ámbito ref1=olv_limp->iaso[refent].refe2; - //ref2 es la calle a la que está asignado + //ref2 es la calle a la que está asignado ref2=olv_limp->inww_amb[ref1].refnw; } else @@ -3572,9 +3638,9 @@ BOOL Colv_limp_thr::busca_conjs() k=1; else k=0; - //el primer nodo el del ámbito + //el primer nodo el del ámbito olv_limp->iaso[refent].inod[0]=olv_limp->iaso[ref1].inod[k]; - //el primer nodo el de la réplica + //el primer nodo el de la réplica olv_limp->iaso[refent].inod[1]=olv_limp->iaso[ref2].inod[k]; } @@ -3594,7 +3660,7 @@ BOOL Colv_limp_thr::busca_conjs() //************************************************************************************* /** * Rellena la matriz de distancias entre todas las conjunciones. - * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado + * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado */ BOOL Colv_limp_thr::calcula_cost_conj_fin() { @@ -3619,8 +3685,8 @@ BOOL Colv_limp_thr::calcula_cost_conj_fin() } //************************************************************************************* /** - * Rellena la matriz de distancias entre todas las conjunciones, es la parte de cálculos que - * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué conjunciones le tocan. + * Rellena la matriz de distancias entre todas las conjunciones, es la parte de cálculos que + * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué conjunciones le tocan. */ void Colv_limp_thr::calcula_cost_conj_sub(int ithr) { @@ -3636,7 +3702,7 @@ void Colv_limp_thr::calcula_cost_conj_sub(int ithr) //////////////// nent=olv_limp->carto.getNumberEntities(); mal=FALSE; - pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso n_desp = (int)ceil(1.0*(nent)/n_subthr); n_ini= min(ithr*n_desp, nent); n_fin = min((ithr+1)*n_desp,nent); @@ -3660,16 +3726,16 @@ void Colv_limp_thr::calcula_cost_conj_sub(int ithr) continue; /////////////////// - //pone en el array de tipos qué es + //pone en el array de tipos qué es olv_limp->tip_conj.set(ics[0],ics[1],refent); olv_limp->tip_conj.set(ics[1],ics[0],refent); /////////////////////////////////// nd+=2; - //ya tiene una línea y sus dos extremos localizados, calcula el coste + //ya tiene una línea y sus dos extremos localizados, calcula el coste calcula_cost(refent,&cost,&cost2); - //añade los costes a la matriz + //añade los costes a la matriz if(cost>olv_limp->cost_conj[ics[0]][ics[1]]) cost=olv_limp->cost_conj[ics[0]][ics[1]]; olv_limp->cost_conj.set(ics[0],ics[1], min(cost,olv_limp->cost_conj[ics[0]][ics[1]])); @@ -3686,7 +3752,7 @@ void Colv_limp_thr::calcula_cost_conj_sub(int ithr) olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Rellenando matriz de dist entre conjs %ld de %ld", ithr, (i-n_ini+1),n_desp); //avisa de progreso - prog_subthr=((1.0*(i-n_ini+1)/n_desp)+0)/3;///3 porque es la tercera parte del progreso los costes de conjunciones y la otra mitad los costes de ámbitos + prog_subthr=((1.0*(i-n_ini+1)/n_desp)+0)/3;///3 porque es la tercera parte del progreso los costes de conjunciones y la otra mitad los costes de ámbitos thr_padre->encola(OLV_LIMP_EV_SUBTHR_PROG,&pp,FALSE); } } @@ -3697,7 +3763,7 @@ void Colv_limp_thr::calcula_cost_conj_sub(int ithr) } //************************************************************************************* /** - * Calcula el coste de la línea io, cost en sentido ida y cost2 en sentido vuelta + * Calcula el coste de la línea io, cost en sentido ida y cost2 en sentido vuelta */ void Colv_limp_thr::calcula_cost(int refent, float *cost, float *cost2) { @@ -3711,7 +3777,7 @@ void Colv_limp_thr::calcula_cost(int refent, float *cost, float *cost2) ltot=olv_limp->carto.getRef(refent).getLong(); if(ltot==0) { - //es un segmento de unión de peat con rep o de eje de calle con nw + //es un segmento de unión de peat con rep o de eje de calle con nw cost=cost2=0; return; } @@ -3721,15 +3787,15 @@ void Colv_limp_thr::calcula_cost(int refent, float *cost, float *cost2) } //************************************************************************************* /** - * Rellena la matriz de ángulos entre las conjunciones adyacentes a una dada + * Rellena la matriz de ángulos entre las conjunciones adyacentes a una dada */ BOOL Colv_limp_thr::calcula_ang_conj() { //////////////// - olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de ángulos entre conjunciones"); + olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de ángulos entre conjunciones"); pon_mi_progre(OLV_TAREA_COST_AMB, (int) (OliviaDef::GeneralDef::ProgrMax*1/3)); - pon_mi_msg("Rellenando matriz de ángulos entre nodos"); + pon_mi_msg("Rellenando matriz de ángulos entre nodos"); err_str[0]=0; //pide memoria para el array de distancias entre conjunciones @@ -3743,8 +3809,8 @@ BOOL Colv_limp_thr::calcula_ang_conj() //************************************************************************************* /** - * Rellena la matriz de ángulos entre todas las conjunciones. - * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado + * Rellena la matriz de ángulos entre todas las conjunciones. + * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado */ BOOL Colv_limp_thr::calcula_ang_conj_fin() { @@ -3766,8 +3832,8 @@ BOOL Colv_limp_thr::calcula_ang_conj_fin() } //************************************************************************************* /** - * Rellena la matriz de ángulos entre todas las conjunciones adyacentes a una dada, es la parte de cálculos que - * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué conjunciones le tocan. + * Rellena la matriz de ángulos entre todas las conjunciones adyacentes a una dada, es la parte de cálculos que + * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué conjunciones le tocan. */ void Colv_limp_thr::calcula_ang_conj_sub(int ithr) { @@ -3781,7 +3847,7 @@ void Colv_limp_thr::calcula_ang_conj_sub(int ithr) double ang; //////////////// - pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso KK=olv_limp->tipo_ambit; nconj=olv_limp->conjs.n; n_desp = (int)ceil(1.0*nconj/n_subthr); @@ -3796,11 +3862,11 @@ void Colv_limp_thr::calcula_ang_conj_sub(int ithr) memset(conjs,0,olv_limp->conjs.n*sizeof(BYTE)); //////////////// - olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Ángulos de conjunciones %04d a %04d", ithr,n_ini, n_fin); + olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Ãngulos de conjunciones %04d a %04d", ithr,n_ini, n_fin); seg = GetTickCount(); ///////////////////////////////////// - //bucle por cada conjunción de la carto + //bucle por cada conjunción de la carto for(ic=n_ini; icang_conj[ic].inicia(nady)) { mal=TRUE; @@ -3867,14 +3933,42 @@ void Colv_limp_thr::calcula_ang_conj_sub(int ithr) } else { - //si no hay restricciones de circulación, se pone que se el ángulo es ok siempre - //si no, se calcula, y el ángulo es ok si es menor que el ángulo límite + //si no hay restricciones de circulación, se pone que se el ángulo es ok siempre + //si no, se calcula, y el ángulo es ok si es menor que el ángulo límite //if(olv_limp->res_circ!=OLV_RES_NO) - { - ang=dame_ang_conj(ic,i,j); - aa=(ang<=olv_limp->ang_lim); - nn++; + if (olv_limp->res_angulos == OLV_RES_NO) + { + ang = dame_ang_conj(ic, i, j); + aa = (ang <= olv_limp->ang_lim); } + else + { + int ia = olv_limp->tip_conj[i][ic]; + float angl =olv_limp->iaso[ia].angulo; + int ia2=olv_limp->tip_conj[j][ic]; + float angl2 = olv_limp->iaso[ia2].angulo; + //se coje el angulo mas limitante + if (angl2 > 0 && angl2 < angl) + { + angl = angl2; + } + //segun angulo limite se hace un tipo de logica u otra + if (angl >0) + { + ang = dame_ang_conj(ic, i, j); + aa = (ang <= olv_limp->ang_lim) && (ang <= (angl * OLV_PI/180.)); + if (!aa) + aa = aa; + } + else if (angl == 0) + { + ang = dame_ang_conj(ic, i, j); + aa = (ang <= olv_limp->ang_lim); + } + else + aa = true; + } + nn++; } olv_limp->ang_conj[ic].pon_ang_i_j(i,j,aa); @@ -3897,13 +3991,13 @@ void Colv_limp_thr::calcula_ang_conj_sub(int ithr) if(conjs) free(conjs); - olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Fin Matriz de ang entre conjs, %ld ángulos, %ld dist 0, %.3f seg", ithr, na,nn,1.0*(GetTickCount()-seg)/1000); + olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Fin Matriz de ang entre conjs, %ld ángulos, %ld dist 0, %.3f seg", ithr, na,nn,1.0*(GetTickCount()-seg)/1000); thr_padre->encola(OLV_LIMP_EV_ANG_CONJ_FIN,NULL,FALSE); } //************************************************************************************* /** - * Devuelve el ángulo entre dos conjunciones + * Devuelve el ángulo entre dos conjunciones */ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) { @@ -3915,7 +4009,7 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) ang=0; - //cambio de sentido en carretera o ámbito + //cambio de sentido en carretera o ámbito if(i==j) { if((olv_limp->iaso[refconj_i].flgs & OLV_LIMP_FLG_NW) || (olv_limp->iaso[refconj_j].flgs & OLV_LIMP_FLG_NW)) @@ -3923,7 +4017,7 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) if(olv_limp->res_circ==OLV_RES_NO) return 0; else - return OLV_PI;//ángulo de 180º en carretera y sigue sentidos, no se puede (excepto si es calle cortada, que se revisa luego) + return OLV_PI;//ángulo de 180º en carretera y sigue sentidos, no se puede (excepto si es calle cortada, que se revisa luego) } else return 0; @@ -3937,12 +4031,12 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) if(((olv_limp->iaso[refconj_i].flgs & OLV_LIMP_FLG_NW_REP) && (olv_limp->iaso[refconj_i].refe2 == refconj_j)) || ((olv_limp->iaso[refconj_j].flgs & OLV_LIMP_FLG_NW_REP) && (olv_limp->iaso[refconj_j].refe2 == refconj_i))) { - //si intenta ir de nw a réplica, pero de la misma calle + //si intenta ir de nw a réplica, pero de la misma calle return OLV_PI; } //return 0; //las dos son carretera, mira si por coste no se puede ir - //calcula los puntos próximos a la conjunción + //calcula los puntos próximos a la conjunción for(t=0;t<2;t++) { if(t==0) @@ -3955,7 +4049,7 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) if(Colv_geom::pto_equals(olv_limp->conjs.coor[ic], p)) { p=ient.getPto(1); - //la conjunción es el primer punto + //la conjunción es el primer punto for(k=0;k<2;k++) { v[t][k]=p[k]-olv_limp->conjs.coor[ic][k]; @@ -3964,7 +4058,7 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) else { p=ient.getPto(npts-2); - //la conjunción es el último punto + //la conjunción es el último punto for(k=0;k<2;k++) { v[t][k]=p[k]-olv_limp->conjs.coor[ic][k]; @@ -3973,13 +4067,78 @@ double Colv_limp_thr::dame_ang_conj(int ic, int i, int j) } ang=Colv_geom::ang_vect(v[0],v[1]); - ang=OLV_PI-ang; + if(ang> OLV_PI) + ang=OLV_PI-ang; return ang; } +double Colv_limp_thr::dame_ang_conj2(int ic, int i, int j) +{ + double ang, * p, v[2][2]; + int npts, k, t; + CartoBaseInfoEntity ient; + int refconj_i = olv_limp->tip_conj[i][ic]; + int refconj_j = olv_limp->tip_conj[j][ic]; + + ang = 0; + + //cambio de sentido en carretera o ámbito + if (i == j) + { + return OLV_PI;//ángulo de 180º en carretera y sigue sentidos, no se puede (excepto si es calle cortada, que se revisa luego) + } + + if (((olv_limp->iaso[refconj_i].flgs & OLV_LIMP_FLG_NW_REP) && (olv_limp->iaso[refconj_i].refe2 == refconj_j)) || + ((olv_limp->iaso[refconj_j].flgs & OLV_LIMP_FLG_NW_REP) && (olv_limp->iaso[refconj_j].refe2 == refconj_i))) + { + //si intenta ir de nw a réplica, pero de la misma calle + return OLV_PI; + } + if (!(olv_limp->iaso[refconj_i].flgs & OLV_LIMP_FLG_NW) || !(olv_limp->iaso[refconj_j].flgs & OLV_LIMP_FLG_NW)) + { + return 0;//uno de los dos no son carretera, se puede siempre + } + //return 0; + //las dos son carretera, mira si por coste no se puede ir + //calcula los puntos próximos a la conjunción + for (t = 0; t < 2; t++) + { + if (t == 0) + ient = olv_limp->carto.getRef(refconj_i); + else + ient = olv_limp->carto.getRef(refconj_j); + + p = ient.getPto(0); + npts = ient.getNumberPtos(); + if (Colv_geom::pto_equals(olv_limp->conjs.coor[ic], p)) + { + p = ient.getPto(1); + //la conjunción es el primer punto + for (k = 0; k < 2; k++) + { + v[t][k] = p[k] - olv_limp->conjs.coor[ic][k]; + } + } + else + { + p = ient.getPto(npts - 2); + //la conjunción es el último punto + for (k = 0; k < 2; k++) + { + v[t][k] = p[k] - olv_limp->conjs.coor[ic][k]; + } + } + } + + ang = Colv_geom::ang_vect(v[0], v[1]); + if (ang > OLV_PI) + ang = OLV_PI - ang; + + return ang; +} //************************************************************************************* /** - * Resvisa los ángulos, de forma que si hay algún giro "prohibido" de 180º, en caso + * Resvisa los ángulos, de forma que si hay algún giro "prohibido" de 180º, en caso * de que sean calles cortadas o sin salida, los pone a ok */ void Colv_limp_thr::revisa_calles_cortadas() @@ -3996,12 +4155,12 @@ void Colv_limp_thr::revisa_calles_cortadas() { if(!olv_limp->ang_conj[ic].angs[i][j]) { - //si el ángulo es prohibido, mira a ver si hay más conjunciones + //si el ángulo es prohibido, mira a ver si hay más conjunciones for(k=0;kang_conj[ic].i_conjs[k]<0 || olv_limp->ang_conj[ic].i_conjs[k]>=olv_limp->conjs.n) { - olvlog(LOG_TODO,"olv_limp_t","Ojo ang_conj fuera de límites ic %ld, k %ld",ic,k); + olvlog(LOG_TODO,"olv_limp_t","Ojo ang_conj fuera de límites ic %ld, k %ld",ic,k); continue; } /*if(((k!=i) || (k!=j)) && (olv_limp->conjs.inc[olv_limp->ang_conj[ic].i_conjs[k]].n>1)) @@ -4012,7 +4171,7 @@ void Colv_limp_thr::revisa_calles_cortadas() (olv_limp->conjs.inc[olv_limp->ang_conj[ic].i_conjs[k]].n>1)) break; } - if(k>=nady)//estos nodos son los únicos que tiene para entrar y salir + if(k>=nady)//estos nodos son los únicos que tiene para entrar y salir { olv_limp->ang_conj[ic].angs[i][j]=1; } @@ -4023,15 +4182,15 @@ void Colv_limp_thr::revisa_calles_cortadas() } //************************************************************************************* /** - * Rellena la matriz de costes entre todos los ámbitos + * Rellena la matriz de costes entre todos los ámbitos */ BOOL Colv_limp_thr::calcula_cost_amb() { //////////////// - olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de costes entre ámbitos"); + olvlog(LOG_TODO,"olv_limp_t","Rellenando matriz de costes entre ámbitos"); pon_mi_progre(OLV_TAREA_COST_AMB, (int) (OliviaDef::GeneralDef::ProgrMax*2/3)); - pon_mi_msg("Rellenando matriz de costes entre ámbitos. %ld ámbitos por calcular",olv_limp->n_amb); + pon_mi_msg("Rellenando matriz de costes entre ámbitos. %ld ámbitos por calcular",olv_limp->n_amb); err_str[0]=0; char st[MAX_PATH]; char st1[MAX_PATH]; @@ -4067,8 +4226,8 @@ BOOL Colv_limp_thr::calcula_cost_amb() } else { - //en modo multitask entra aquí cuando ya han terminado las tasks - //se lee la matriz de ámbitos que han guardado las tasks + //en modo multitask entra aquí cuando ya han terminado las tasks + //se lee la matriz de ámbitos que han guardado las tasks if(!olv_limp->arch_dj.lee_dis()) return FALSE; if(!olv_limp->olv_tasks->lee_cost_amb(olv_limp->cost_amb)) @@ -4077,10 +4236,10 @@ BOOL Colv_limp_thr::calcula_cost_amb() //borra los archivos temporales borra_temp_files(FALSE); - //después de leerla, encola el cost_amb_fin + //después de leerla, encola el cost_amb_fin for(int i=0;iprog_subthr=0;//para que no dé error + subthrs[i]->prog_subthr=0;//para que no dé error encola(OLV_LIMP_EV_COST_AMB_FIN,NULL,FALSE); } } @@ -4092,10 +4251,10 @@ BOOL Colv_limp_thr::inicia_cost_amb() { int i,j; - //pide memoria para el array de distancias entre ámbitos + //pide memoria para el array de distancias entre ámbitos if(!olv_limp->cost_amb.inicia(olv_limp->n_amb,olv_limp->n_amb)) { - pon_mi_msg("Error, sin memoria para matriz de dist entre ámbitos"); + pon_mi_msg("Error, sin memoria para matriz de dist entre ámbitos"); return FALSE; } @@ -4119,8 +4278,8 @@ BOOL Colv_limp_thr::inicia_cost_amb() } //************************************************************************************* /** - * Rellena la matriz de distancias entre todos los ámbitos. - * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado + * Rellena la matriz de distancias entre todos los ámbitos. + * El thread entra aquí cuando los subthreads que realizan la tarea realmente han finalizado */ BOOL Colv_limp_thr::calcula_cost_amb_fin() { @@ -4149,13 +4308,13 @@ BOOL Colv_limp_thr::calcula_cost_amb_fin() //calcula el coste a las plantas if(!calcula_cost_plant()) { - pon_mi_msg("Error, planta o instalación aisladas"); + pon_mi_msg("Error, planta o instalación aisladas"); return FALSE; } olv_limp->nsec_act=olv_limp->nsec; - olvlog(LOG_TODO,"olv_limp_t","FIN Matriz de dist entre ámbitos %ldx%ld", + olvlog(LOG_TODO,"olv_limp_t","FIN Matriz de dist entre ámbitos %ldx%ld", olv_limp->n_amb,olv_limp->n_amb); return TRUE; @@ -4177,12 +4336,12 @@ BOOL Colv_limp_thr::avisa_aislados() ambs_ais = (BYTE*)malloc(olv_limp->n_amb); if(!ambs_ais) { - pon_mi_msg("Error, sin memoria en fin de calcula coste ámbitos"); + pon_mi_msg("Error, sin memoria en fin de calcula coste ámbitos"); return FALSE; } memset(ambs_ais,0,olv_limp->n_amb); - //revisa costes de ámbitos + //revisa costes de ámbitos int nais; for(i=0;in_amb; i++) { @@ -4210,14 +4369,14 @@ BOOL Colv_limp_thr::avisa_aislados() { if(k==i) continue; - if(olv_limp->cost_amb[k][j]>=MAYUSCULO)//comprueba si j está aislado para los demás ámbitos también + if(olv_limp->cost_amb[k][j]>=MAYUSCULO)//comprueba si j está aislado para los demás ámbitos también { nais=j; break; } if(k==j) continue; - if(olv_limp->cost_amb[i][k]>=MAYUSCULO)//comprueba si i está aislado para los demás ámbitos también + if(olv_limp->cost_amb[i][k]>=MAYUSCULO)//comprueba si i está aislado para los demás ámbitos también { nais=i; break; @@ -4248,7 +4407,7 @@ BOOL Colv_limp_thr::avisa_aislados() inw2=0; flgs2=0; } - olvlog(LOG_TODO,"olv_limp_t","Ámbito %05d aislado, inw1 %05d inw2 %05d, flags amb %02X inw1 %02X inw2 %02X ",i,inw,inw2, + olvlog(LOG_TODO,"olv_limp_t","Ãmbito %05d aislado, inw1 %05d inw2 %05d, flags amb %02X inw1 %02X inw2 %02X ",i,inw,inw2, olv_limp->iaso[i].flgs,olv_limp->iaso[inw].flgs,flgs2); } } @@ -4260,16 +4419,16 @@ BOOL Colv_limp_thr::avisa_aislados() } if(nais==1) - sprintf_s(ais_msg,"Encontrado %ld ámbito aislado %s: ", nais,olv_limp->igno_ais?"(Se ignora)":""); + sprintf_s(ais_msg,"Encontrado %ld ámbito aislado %s: ", nais,olv_limp->igno_ais?"(Se ignora)":""); else - sprintf_s(ais_msg,"Encontrados %ld ámbitos aislados %s: ",nais,olv_limp->igno_ais?"(Se ignoran)":""); + sprintf_s(ais_msg,"Encontrados %ld ámbitos aislados %s: ",nais,olv_limp->igno_ais?"(Se ignoran)":""); int inais=0; for(i=0;in_amb;i++) { if(ambs_ais[i]) { ref_i=olv_limp->carto.get(i).entity()->ref; - if(olv_limp->igno_ais)//si toca ignorar aislados, lo marca para ignorarlo en la sectorización + if(olv_limp->igno_ais)//si toca ignorar aislados, lo marca para ignorarlo en la sectorización { olv_limp->iaso[ref_i].flgs|=OLV_LIMP_FLG_AMB_NO; } @@ -4308,7 +4467,7 @@ BOOL Colv_limp_thr::avisa_aislados() } //************************************************************************************* /** - * Apunta en qué nodos está la planta y la instalación + * Apunta en qué nodos está la planta y la instalación */ BOOL Colv_limp_thr::calcula_cost_plant() { @@ -4327,7 +4486,7 @@ BOOL Colv_limp_thr::calcula_cost_plant() return FALSE; } memset(olv_limp->ord_sec_plan,0,sizeof(Secu_amb)); - olvlog(LOG_TODO,"olv_limp_t","Calculando coste a planta e instalación"); + olvlog(LOG_TODO,"olv_limp_t","Calculando coste a planta e instalación"); costes_nodos=NULL; k=0; @@ -4337,7 +4496,7 @@ BOOL Colv_limp_thr::calcula_cost_plant() if(!Colv_geom::dijkstra_ang_inv_ok(olv_limp->cost_conj, olv_limp->ang_conj, olv_limp->conjs.n, ic, &costes_nodos, &visto_ang)) { - pon_mi_msg("Error al calcular costes de ámbitos a instalación"); + pon_mi_msg("Error al calcular costes de ámbitos a instalación"); return FALSE; } @@ -4346,7 +4505,7 @@ BOOL Colv_limp_thr::calcula_cost_plant() costes_nodos=NULL; - //revisa si está aislado de algún ámbito + //revisa si está aislado de algún ámbito nais=0; for(ia=0;ian_amb;ia++) { @@ -4366,7 +4525,7 @@ BOOL Colv_limp_thr::calcula_cost_plant() } if(ian_amb) { - pon_mi_msg("Error al calcular costes de ámbitos a instalación"); + pon_mi_msg("Error al calcular costes de ámbitos a instalación"); return FALSE; } @@ -4374,8 +4533,8 @@ BOOL Colv_limp_thr::calcula_cost_plant() } //************************************************************************************* /** - * Rellena la matriz de distancias entre todos los ámbitos, es la parte de cálculos que - * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué ámbitos le tocan. + * Rellena la matriz de distancias entre todos los ámbitos, es la parte de cálculos que + * realizan los subthreads. 'ithr' indica qué thread es, para calcular qué ámbitos le tocan. */ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) { @@ -4390,7 +4549,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) int ref_na, ref_i, amb_i, amb_na; //////////////// - pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_COST_AMB;//manda de parámetro la tarea de la que es el progreso KK=olv_limp->tipo_ambit; na_desp = (int)ceil(1.0*(olv_limp->n_amb)/n_subthr); na_ini= min(ithr*na_desp, olv_limp->n_amb); @@ -4402,24 +4561,24 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) seg = GetTickCount(); ///////////////////////////////////// - //Bucle por cada ámbito de los que le tocan a este thread + //Bucle por cada ámbito de los que le tocan a este thread ///////////////////////////////////// - //el coste de un ámbito a sí mismo es el de trabajar ese ámbito, + //el coste de un ámbito a sí mismo es el de trabajar ese ámbito, //que es el coste de ir de su conj inicial a la final na=na_ini; ///////////////////////////////////// for(na=na_ini;naias[i].ic_ini está almacenado el índice de la conjunción del nodo inicial del ámbito + //En olv_limp->ias[i].ic_ini está almacenado el índice de la conjunción del nodo inicial del ámbito //y en olv_limp->ias[i].ic_fin el del final. ///////////////////////////////////////////// - //calcula el coste máximo del ámbito na a todos los demás - //los añade a la fila na de la matriz de costes - //es coste máximo porque hace el máximo de: + //calcula el coste máximo del ámbito na a todos los demás + //los añade a la fila na de la matriz de costes + //es coste máximo porque hace el máximo de: //inicio(na)->inicio(ni), inicio(na)->final(ni), final(na)->inicio(ni), final(na)->final(ni) ///////////////////////////////////////////// - //k==0, calcula las distancias del nodo inicial de ese ámbito a todas las demás conjunciones + //k==0, calcula las distancias del nodo inicial de ese ámbito a todas las demás conjunciones //k==1, calucla las distancias del nodo final ient_na = olv_limp->carto.get(na); ref_na = ient_na.entity()->ref; @@ -4436,7 +4595,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) break; } - //recorre todos los demás ámbitos buscando el coste a ellos en el array de costes devuelto, y los almacena + //recorre todos los demás ámbitos buscando el coste a ellos en el array de costes devuelto, y los almacena //almacena el coste a su nodo inicial y a su nodo final if(olv_limp->iaso[ref_na].flgs & OLV_LIMP_FLG_AMB_NO) { @@ -4459,7 +4618,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) continue; if(na==i) { - //el coste de un ámbito a sí mismo es el de trabajar ese ámbito + //el coste de un ámbito a sí mismo es el de trabajar ese ámbito olv_limp->cost_amb[amb_na][amb_na]=olv_limp->cost_conj[olv_limp->iaso[ref_na].inod[0]][olv_limp->iaso[ref_na].inod[1]]; continue; } @@ -4494,7 +4653,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) if(mal) break; - //si es ámbito lineal calcula la distancia media de los cuatro nodos + //si es ámbito lineal calcula la distancia media de los cuatro nodos if(na==1) if(log_debug) { @@ -4504,7 +4663,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) caux=-1; else caux=olv_limp->cost_amb[amb_na][amb_i]; - olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Coste ámb %ld a ámb %ld es %lf", ithr, + olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Coste ámb %ld a ámb %ld es %lf", ithr, na,i,caux); } } @@ -4528,7 +4687,7 @@ void Colv_limp_thr::calcula_cost_amb_sub(int ithr) if(mal) { - olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Error en cálculo de matriz de distancias entre ámbitos", ithr); + olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Error en cálculo de matriz de distancias entre ámbitos", ithr); prog_subthr=-1;//para avisar al padre de que ha habido un error } else @@ -4550,7 +4709,7 @@ BOOL Colv_limp_thr::sectoriza() if(olv_limp->n_amb<2) { - pon_mi_msg("Error, número de ámbitos es %ld",olv_limp->n_amb); + pon_mi_msg("Error, número de ámbitos es %ld",olv_limp->n_amb); return FALSE; } @@ -4560,19 +4719,19 @@ BOOL Colv_limp_thr::sectoriza() if(!pide_memo_secto()) { - pon_mi_msg("Error, Sin memoria para sectorización"); + pon_mi_msg("Error, Sin memoria para sectorización"); return FALSE; } ////////////////////////////////////////////////////////////// - olvlog(LOG_TODO,"olv_limp_t","Comienza sectorización %ld ámbitos en %ld sectores", + olvlog(LOG_TODO,"olv_limp_t","Comienza sectorización %ld ámbitos en %ld sectores", olv_limp->n_amb, olv_limp->nsec_act); /////////////////////////////////////// //Algoritmo 1 if(!sectoriza_1()) { - pon_mi_msg("Errores producidos en sectorización: %s",err_str); + pon_mi_msg("Errores producidos en sectorización: %s",err_str); res=FALSE; goto pinta; } @@ -4583,22 +4742,22 @@ BOOL Colv_limp_thr::sectoriza() copia_info_barr_mix(); ////////////////////////////////////////////////////////////////////////////// - //Guarda el shape añadiendo la columna de sector + //Guarda el shape añadiendo la columna de sector if(!guarda_dbf_sector(0)) { - pon_mi_msg("Errores producidos en sectorización: %s",err_str); + pon_mi_msg("Errores producidos en sectorización: %s",err_str); return FALSE; } - //Guarda el shape añadiendo la columna de secuencia vacía + //Guarda el shape añadiendo la columna de secuencia vacía if(!guarda_dbf_sector(1)) { - pon_mi_msg("Errores producidos en sectorización: %s",err_str); + pon_mi_msg("Errores producidos en sectorización: %s",err_str); return FALSE; } ////////////////////////////////////////////////////////////////////////////// for(i=0;insec;i++) { - olvlog(LOG_TODO,"olv_limp_t","Sector %ld, %03d ámbitos, coste total %lf",i,olv_limp->sec[i].namb, olv_limp->sec[i].cost_ac); + olvlog(LOG_TODO,"olv_limp_t","Sector %ld, %03d ámbitos, coste total %lf",i,olv_limp->sec[i].namb, olv_limp->sec[i].cost_ac); } olvlog(LOG_TODO,"olv_limp_t","Finalizada generacion de sectores--------------------------"); @@ -4608,7 +4767,7 @@ pinta: } //************************************************************************************* /** - * Pide memoria e inicializa los arrays para la sectorización + * Pide memoria e inicializa los arrays para la sectorización */ BOOL Colv_limp_thr::pide_memo_secto() { @@ -4631,7 +4790,7 @@ BOOL Colv_limp_thr::pide_memo_secto() return FALSE; } } - //inicializa todo a mayúsculo + //inicializa todo a mayúsculo for(i=0;insec;i++) { olv_limp->sec[i].namb=0; @@ -4644,11 +4803,11 @@ BOOL Colv_limp_thr::pide_memo_secto() } } ////////////////////////////////////////////////////////////// - //pide memoria para el array de ámbitos asignados al sector + //pide memoria para el array de ámbitos asignados al sector olv_limp->amb_sec = (Info_amb_sec *)malloc(olv_limp->n_amb*sizeof(Info_amb_sec)); if(!olv_limp->amb_sec) { - pon_mi_msg("Error, sin memoria para matriz de ámbitos en los sectores"); + pon_mi_msg("Error, sin memoria para matriz de ámbitos en los sectores"); return FALSE; } memset(olv_limp->amb_sec,0,olv_limp->n_amb*sizeof(Info_amb_sec)); @@ -4666,7 +4825,7 @@ BOOL Colv_limp_thr::pide_memo_secto() } //************************************************************************************* /** - * Añade el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios + * Añade el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios */ BOOL Colv_limp_thr::add_amb_sec(int i_amb, int namb, int i_sec, Info_sec *ss, Info_amb_sec *aa, Matrix2d &cost_amb, double cost_tot, int i_amb_p) { @@ -4674,15 +4833,15 @@ BOOL Colv_limp_thr::add_amb_sec(int i_amb, int namb, int i_sec, Info_sec *ss, In return FALSE; ss[i_sec].iamb[ss[i_sec].namb]=i_amb; ss[i_sec].namb++; - //apunta el ámbito al sector + //apunta el ámbito al sector aa[i_amb].sec=i_sec; return TRUE; } //************************************************************************************* /** - * Le quita el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios - * Actualiza el coste que es el que lleva, mas el desplazamiento del que ya tiene al nuevo, más el coste del nuevo + * Le quita el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios + * Actualiza el coste que es el que lleva, mas el desplazamiento del que ya tiene al nuevo, más el coste del nuevo * Al salir, hay que actualizar las distancias! */ void Colv_limp_thr::quita_amb_sec(int i_amb, int namb, int i_sec, Info_sec *ss, Info_amb_sec *aa, Matrix2d &cost_amb, int i_amb_p) @@ -4694,21 +4853,21 @@ void Colv_limp_thr::quita_amb_sec(int i_amb, int namb, int i_sec, Info_sec *ss, break; } if(i>=ss[i_sec].namb) - return ; //no lo tenía este sector + return ; //no lo tenía este sector - //le quita de su array de índices si tiene al menos uno posterior + //le quita de su array de índices si tiene al menos uno posterior for(j=i;j &cost_amb, Info_sec *ss, Info_amb_sec *aa) { @@ -4756,12 +4915,12 @@ BOOL Colv_limp_thr::genera_sectores3(int iamb_extr, int n_amb, int n_sec, Matrix } if(k<0) { - return FALSE;//no debería + return FALSE;//no debería } add_amb_sec(k,n_amb,s,ss,aa,cost_amb,MAYUSCULO,-1); } - //asigna el resto de ámbitos al último sector s=n-1 + //asigna el resto de ámbitos al último sector s=n-1 for (j=0; j=0) @@ -4777,8 +4936,8 @@ BOOL Colv_limp_thr::genera_sectores3(int iamb_extr, int n_amb, int n_sec, Matrix } //************************************************************************************* /** - * Añade el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios - * Actualiza el coste que es el que lleva, mas el desplazamiento del que ya tiene al nuevo, más el coste del nuevo + * Añade el ámbito 'i_amb' al sector 'i_sec', actualizando la info en todos los lugares necesarios + * Actualiza el coste que es el que lleva, mas el desplazamiento del que ya tiene al nuevo, más el coste del nuevo */ BOOL Colv_limp_thr::add_amb_sec_cost(int i_amb, int namb, int i_sec, Info_sec *ss, Info_amb_sec *aa, Matrix2d &cost_amb) { @@ -4786,11 +4945,11 @@ BOOL Colv_limp_thr::add_amb_sec_cost(int i_amb, int namb, int i_sec, Info_sec *s return FALSE; ss[i_sec].iamb[ss[i_sec].namb]=i_amb; ss[i_sec].namb++; - //apunta el ámbito al sector + //apunta el ámbito al sector aa[i_amb].sec=i_sec; //actualiza el coste del sector - //si no es el primer ámbito, suma el coste de ir del anterior a este + //si no es el primer ámbito, suma el coste de ir del anterior a este double dmed; int k; dmed=0; @@ -4804,7 +4963,7 @@ BOOL Colv_limp_thr::add_amb_sec_cost(int i_amb, int namb, int i_sec, Info_sec *s dmed=dmed/(3*olv_limp->tipo_ambit-2); ss[i_sec].cost_ac+=(float)dmed; } - //suma el coste de hacer el ámbito + //suma el coste de hacer el ámbito ss[i_sec].cost_ac+=cost_amb[i_amb][i_amb]; return TRUE; @@ -4925,18 +5084,18 @@ BOOL Colv_limp_thr::genera_sectores(int iamb_extr, int n_amb, int n_sec, Matrix cos_acum_sec=ss[isec[isec_min]].cost_ac; k=-1; d=MAYUSCULO; - //se recorre todos los ámbitos del sector + //se recorre todos los ámbitos del sector for (i=0; i=0; ii--) { j=aa[jj].iamb_cerca[ii]; if(aa[j].sec>=0) continue; - //calcula la distancia media de ese ámbito cercano al sector al que lo intenta añadir + //calcula la distancia media de ese ámbito cercano al sector al que lo intenta añadir dmed=dame_dmed_amb_sec(j,isec[isec_min]); if(dmed2) { @@ -5053,14 +5212,14 @@ BOOL Colv_limp_thr::genera_sectores(int iamb_extr, int n_amb, int n_sec, Matrix } //************************************************************************************* /** - * Devuelve la distancia media del sector isec al ámbito iamb + * Devuelve la distancia media del sector isec al ámbito iamb */ double Colv_limp_thr::dame_dmed_amb_sec(int iamb, int isec) { int i;//,j; double dmed, dmedtot; dmed=dmedtot=0; - //se recorre todos los ámbitos del sector + //se recorre todos los ámbitos del sector for (i=0; isec[isec].namb; i++) { dmed=dame_dmed_amb(i, iamb); @@ -5070,7 +5229,7 @@ double Colv_limp_thr::dame_dmed_amb_sec(int iamb, int isec) } //************************************************************************************* /** - * Devuelve la distancia media entre ámbitos (sobre todo para cuando son lineales) + * Devuelve la distancia media entre ámbitos (sobre todo para cuando son lineales) */ double Colv_limp_thr::dame_dmed_amb(int iamb1, int iamb2) { @@ -5089,7 +5248,7 @@ double Colv_limp_thr::dame_dmed_amb(int iamb1, int iamb2) } //************************************************************************************* /** - * Prueba sectorizacion algoritmo pro, sectoriza basado en ámbitos, no en sectores + * Prueba sectorizacion algoritmo pro, sectoriza basado en ámbitos, no en sectores */ BOOL Colv_limp_thr::genera_sectores_pro(int n_sec, Matrix2d &cost_amb, Info_sec *ss, Info_amb_sec *aa) { @@ -5102,7 +5261,7 @@ BOOL Colv_limp_thr::genera_sectores_pro(int n_sec, Matrix2d &cost_amb, In int nmax, bloq; int oo[2]; - //asigna cada ámbito a un sector + //asigna cada ámbito a un sector namb=olv_limp->n_amb; bloq=1; n=0; @@ -5120,18 +5279,18 @@ BOOL Colv_limp_thr::genera_sectores_pro(int n_sec, Matrix2d &cost_amb, In nsec=namb-n; nmax=(int)(nsec/n_sec*1.3); - //lo hace hasta que ya quedan solo el número de sectores que tienen que quedar + //lo hace hasta que ya quedan solo el número de sectores que tienen que quedar while(nsec>n_sec) { dmin=DBL_MAX; k=kk=-1; - //recorre los ámbitos, y coge el que tenga un ámbito que pertenezca a - //otro sector que esté a la distancia mínima + //recorre los ámbitos, y coge el que tenga un ámbito que pertenezca a + //otro sector que esté a la distancia mínima for(i=0;iiaso[olv_limp->carto.get(i).entity()->ref].flgs & OLV_LIMP_FLG_AMB_NO)//se ha marcado para no usarse, por aislado o por carga insuficiente continue; - //comprueba que el sector no esté creciendo demasiado + //comprueba que el sector no esté creciendo demasiado if(sec[aa[i].sec].size()>nmax) continue; for(j=0;j &cost_amb, In if((bloq*sec[aa[jj].sec].size())>nmax) continue; //////////////////////////////// - //calcula la dist media entre el jj y todos los ámbitos del sector de i + //calcula la dist media entre el jj y todos los ámbitos del sector de i d=0; n=(int)sec[aa[i].sec].size(); for (t=0; t &cost_amb, In dmin=d; k=i; kk=jj; - break;//se pira porque los cercanos están ordenados, - //cuando encuentra uno que le vale ya los siguientes van a estar más lejos + break;//se pira porque los cercanos están ordenados, + //cuando encuentra uno que le vale ya los siguientes van a estar más lejos } } } @@ -5170,24 +5329,24 @@ BOOL Colv_limp_thr::genera_sectores_pro(int n_sec, Matrix2d &cost_amb, In continue; } bloq=1; - //ya tiene qué dos ámbitos están a distancia mínima - //añade al sector de menor índice todos los ámbitos del sector de mayor índice de esos dos ámbitos - //mira cuál es el sector de menor índice + //ya tiene qué dos ámbitos están a distancia mínima + //añade al sector de menor índice todos los ámbitos del sector de mayor índice de esos dos ámbitos + //mira cuál es el sector de menor índice s=aa[k].sec; s2=aa[kk].sec; - //a ese le añade todos los ámbitos del otro sector + //a ese le añade todos los ámbitos del otro sector sec[s].insert(sec[s].end(),sec[s2].begin(),sec[s2].end()); for(i=0;i &cost_amb, In } //************************************************************************************* /** - * Prueba sectorización algoritmo 1, expansión según cercanía de árbol de coste mínimo + * Prueba sectorización algoritmo 1, expansión según cercanía de árbol de coste mínimo */ BOOL Colv_limp_thr::sectoriza_1() { @@ -5217,7 +5376,7 @@ BOOL Colv_limp_thr::sectoriza_1() dd=0; ///////////////////////////////////// - //calcula el árbol de coste mínimo para rellenar cercanos + //calcula el árbol de coste mínimo para rellenar cercanos if(!rellena_amb_cercanos_por_carretera(olv_limp->n_amb, olv_limp->amb_sec, olv_limp->ord_sec)) { sprintf_s(err_str,OLV_MAX_ERR,"Error al rellenar ambitos cercanos por carretera"); @@ -5231,7 +5390,7 @@ BOOL Colv_limp_thr::sectoriza_1() } ////////////////////// - //Como primer ámbito coge el más extremo + //Como primer ámbito coge el más extremo //el de menor 'y+x' maxx=MAYUSCULO; int ref_amb; @@ -5259,7 +5418,7 @@ BOOL Colv_limp_thr::sectoriza_1() return FALSE; } - //si se ha calculado el número de sectores ya se ha sectorizado inicialmente, no hay que llamar a genera_sectores + //si se ha calculado el número de sectores ya se ha sectorizado inicialmente, no hay que llamar a genera_sectores int nsec; if(olv_limp->calc_nsec==0) { @@ -5268,8 +5427,8 @@ BOOL Colv_limp_thr::sectoriza_1() else { nsec=olv_limp->nsec_act; - //entra aquí si ha calculado el número de sectores, y ya va a sectorizar - //en este modo, primero usa solo los dos primeros sectores, al primero le da un ámbito y al segundo el resto de ámbitos + //entra aquí si ha calculado el número de sectores, y ya va a sectorizar + //en este modo, primero usa solo los dos primeros sectores, al primero le da un ámbito y al segundo el resto de ámbitos } if(!genera_sectores_pro(nsec,olv_limp->cost_amb,olv_limp->sec, olv_limp->amb_sec)) @@ -5289,10 +5448,10 @@ BOOL Colv_limp_thr::sectoriza_1() } else { - //entra aquí si ha calculado el número de sectores, y ya va a sectorizar + //entra aquí si ha calculado el número de sectores, y ya va a sectorizar dd=iguala_sectores5(iamb,olv_limp->n_amb, olv_limp->nsec, olv_limp->cost_amb, olv_limp->sec, olv_limp->amb_sec); } - olvlog(LOG_TODO,"olv_limp_t","Conseguida una desviación de: %lf",dd); + olvlog(LOG_TODO,"olv_limp_t","Conseguida una desviación de: %lf",dd); } else { @@ -5304,7 +5463,7 @@ BOOL Colv_limp_thr::sectoriza_1() if(dd<0)//si es -2, aislados, ya lo ha puesto el iguala_sectores4 { if(dd==-2) - sprintf_s(err_str,OLV_MAX_ERR,"Existen ámbitos aislados que\nno ha sido posible unir a la red"); + sprintf_s(err_str,OLV_MAX_ERR,"Existen ámbitos aislados que\nno ha sido posible unir a la red"); return FALSE; } @@ -5483,7 +5642,7 @@ BOOL Colv_limp_thr::quita_islas(int namb, Info_amb_sec *aa, Secu_amb * ord_sec) int amb_act=amb_pend.top(); amb_pend.pop(); islas[amb_act]=nis; - //añade cercanos a la pila + //añade cercanos a la pila for (int k =0 ; k-1) @@ -5532,7 +5691,7 @@ BOOL Colv_limp_thr::quita_islas(int namb, Info_amb_sec *aa, Secu_amb * ord_sec) if(iamb<0) goto va_mal; aa[iamb].iamb_cerca[aa[iamb].namb_cerca++]=iamb_cerca; - //le pone cercano también recíproco//ojo + //le pone cercano también recíproco//ojo if(aa[iamb_cerca].namb_cercaconjs.n;n++) { for (i=0;iiaso[ref_i].inod[j]==n ) { - //Ha encontrado que esta conjunción conecta con el ámbito iésimo + //Ha encontrado que esta conjunción conecta con el ámbito iésimo conex[n]=i; //Sale de los dos bucles i=namb; @@ -5672,16 +5831,16 @@ BOOL Colv_limp_thr::rellena_amb_cercanos_por_carretera(int namb, Info_amb_sec * Colv_geom::ruta_dj_inv_ok(oo[1], secu1, buf_aux[oo[0]],olv_limp->conjs.n, &r1); - //Recorre los nodos de la ruta entre esos ámbitos para ver si alguno de los nodos no conecta directamente - //con algún ámbito, en cuyo caso lo descarta - //o lo descarta también si lleva varios nodos de carretera seguidos + //Recorre los nodos de la ruta entre esos ámbitos para ver si alguno de los nodos no conecta directamente + //con algún ámbito, en cuyo caso lo descarta + //o lo descarta también si lleva varios nodos de carretera seguidos rr=0; for (n=0;n0 && conex[secu1[n]]==-1 && conex[secu1[n-1]]==-1) rr++; else if( n<(r1-2)) @@ -5787,7 +5946,7 @@ int Colv_limp_thr::compara_dist_cerc (const void * a, const void * b) } //************************************************************************************* /** - * Busca el sector más cercano a un ámbito + * Busca el sector más cercano a un ámbito * busca el ambito frontera de iamb mas cercano al sector id_sec * si modo==1 busca se busca a cualquier sector menos id_sec */ @@ -5811,7 +5970,7 @@ int Colv_limp_thr::busca_sec_cerca_amb(Info_amb_sec *aa,int iamb, int id_sec, in } //************************************************************************************* /** - * Ordena los sectores según coste de mayor a menor + * Ordena los sectores según coste de mayor a menor */ int* Colv_limp_thr::ordena_sec( int n_sec, Info_sec *ss, int *buf ) { @@ -5846,7 +6005,7 @@ int* Colv_limp_thr::ordena_sec( int n_sec, Info_sec *ss, int *buf ) } //************************************************************************************* /** - * Algoritmo 5 de igualación de sectores, pasando ámbitos de un sector a otro que tenga cerca + * Algoritmo 5 de igualación de sectores, pasando ámbitos de un sector a otro que tenga cerca */ double Colv_limp_thr::iguala_sectores5(int iamb, int n_amb, int n_sec, Matrix2d &cost_amb, Info_sec *ss, Info_amb_sec *aa) { @@ -5862,10 +6021,10 @@ double Colv_limp_thr::iguala_sectores5(int iamb, int n_amb, int n_sec, Matrix2d< desv=0; - //llama al iguala_sect4 con, al principio sólo 2 sectores activos - //luego comprueba si el último de los nsec su coste es mayor que la jornada - //y si es así, nsec_act++, cuidando que no pase de nsec - //se le añade un ámbito, el más lejano de nsec_act + //llama al iguala_sect4 con, al principio sólo 2 sectores activos + //luego comprueba si el último de los nsec su coste es mayor que la jornada + //y si es así, nsec_act++, cuidando que no pase de nsec + //se le añade un ámbito, el más lejano de nsec_act //si su coste es cero, nsec_act-- //si es el coste es >0 y <= que el coste jornada, todo ok do @@ -5882,7 +6041,7 @@ double Colv_limp_thr::iguala_sectores5(int iamb, int n_amb, int n_sec, Matrix2d< { if((olv_limp->nsec_act-1)<=0) { - //sale bien, pero forzado, no debería salir por aquí.. + //sale bien, pero forzado, no debería salir por aquí.. res=RES_SALE_BIEN; continue; } @@ -5891,10 +6050,10 @@ double Colv_limp_thr::iguala_sectores5(int iamb, int n_amb, int n_sec, Matrix2d< } else if(ss[olv_limp->nsec_act-1].cost_ac>olv_limp->calc_nsec) { - //añade un sec activo, siempre que haya disponibles + //añade un sec activo, siempre que haya disponibles if((olv_limp->nsec_act+1)>olv_limp->nsec) { - //sale bien, pero forzado, no debería salir por aquí.. + //sale bien, pero forzado, no debería salir por aquí.. res=RES_SALE_BIEN; continue; } @@ -5974,7 +6133,7 @@ double Colv_limp_thr::iguala_sectores5(int iamb, int n_amb, int n_sec, Matrix2d< } //************************************************************************************* /** - * Algoritmo 4 de igualación de sectores, pasando ámbitos de un sector a otro que tenga cerca + * Algoritmo 4 de igualación de sectores, pasando ámbitos de un sector a otro que tenga cerca */ double Colv_limp_thr::iguala_sectores4(int n_amb, int n_sec, Matrix2d &cost_amb, Info_sec *ss, Info_amb_sec *aa) { @@ -6082,7 +6241,7 @@ double Colv_limp_thr::iguala_sectores4(int n_amb, int n_sec, Matrix2d &co todo_ok=TRUE; break; } - //busca ambito mas pequeño posible que tenga otro de otro sector más cerca + //busca ambito mas pequeño posible que tenga otro de otro sector más cerca d=MAYUSCULO; iamb=-1; for (i=0; i &co } if(d>=MAYUSCULO || sec<0) { - sprintf_s(err_str,OLV_MAX_ERR,"Error, no encuentra más ámbitos cercanos"); + sprintf_s(err_str,OLV_MAX_ERR,"Error, no encuentra más ámbitos cercanos"); if(desv &co } //selecciona sector a bloquear (el basura) sselc=n_sec-1; - //busca ambito mas pequeño posible + //busca ambito mas pequeño posible d=MAYUSCULO; for (i=0; i &cost_amb, Info_sec *ss, Info_amb_sec *aa, Secu_amb * ord_sec, th_param_planif *thp) { - double desv,desv_last, desv_fut,desv_abs;//máxima desviación permitida respecto a la media + double desv,desv_last, desv_fut,desv_abs;//máxima desviación permitida respecto a la media BOOL hay_cambio,log_debug, prime; int *amb_fron;//indice a ambitos frontera de sectores int *isec=NULL;//indice a sectores (ordenados de mayor a menor) @@ -6335,7 +6494,7 @@ double Colv_limp_thr::iguala_sectores3(int n_amb, int n_sec, Matrix2d &c if(!isec) { olvlog(LOG_TODO,"olv_limp_t","Error en igualacion de sectores 3, sin memoria para bufferes"); - return desv_last;//no debería pasar + return desv_last;//no debería pasar } icerca=&isec[n_sec+1]; icamb=&icerca[n_amb*2]; @@ -6447,7 +6606,7 @@ double Colv_limp_thr::iguala_sectores3(int n_amb, int n_sec, Matrix2d &c for(i=amb_fron[isec[j]*siz_sec]-1; i>=0; i--) { //verifica que tenga ambitos cercanos de otros sectores - //si es asi añade al array + //si es asi añade al array k=busca_sec_cerca_amb(aa,amb_fron[kk+i], isec[isec_min],1); if(k>=0) { @@ -6647,14 +6806,14 @@ double Colv_limp_thr::iguala_sectores3(int n_amb, int n_sec, Matrix2d &c } if(log_debug) - olvlog(LOG_TODO,"olv_limp_t","Finalizada igualación de sectores 3----------------"); + olvlog(LOG_TODO,"olv_limp_t","Finalizada igualación de sectores 3----------------"); return desv_last; } //************************************************************************************* /** - * Calcula la desviación típica entre los costes acumulados de los nsec sectores - * Si porc=true, la desviación la devuelve en porcentaje respecto a la media, si no, absoluta + * Calcula la desviación típica entre los costes acumulados de los nsec sectores + * Si porc=true, la desviación la devuelve en porcentaje respecto a la media, si no, absoluta * en absol se mete la maxima desviacion encontrada */ double Colv_limp_thr::dame_desv_sec(int nsec, Info_sec *ss, BOOL porc /*=FALSE*/, double *absol) @@ -6670,7 +6829,7 @@ double Colv_limp_thr::dame_desv_sec(int nsec, Info_sec *ss, BOOL porc /*=FALSE*/ if(olv_limp->calc_nsec>0) { cost_med=olv_limp->calc_nsec; //impone el coste medio de los sectores, que es justo la jornada laboral - nsec--; //se quita un sector, el último, para el cálculo de la media + nsec--; //se quita un sector, el último, para el cálculo de la media } else { @@ -6679,12 +6838,12 @@ double Colv_limp_thr::dame_desv_sec(int nsec, Info_sec *ss, BOOL porc /*=FALSE*/ cost_med+=ss[j].cost_ac/nsec; } } - //calcula la desviación típica + //calcula la desviación típica for(j=0;jcalc_nsec>0) && (dd>0)) { dd+=cost_med*nsec*2; @@ -6696,7 +6855,7 @@ double Colv_limp_thr::dame_desv_sec(int nsec, Info_sec *ss, BOOL porc /*=FALSE*/ } if(olv_limp->calc_nsec>0) { - if(((ss[nsec].cost_ac-cost_med)>0))//si está en modo fijar jornada, tampoco queremos que se desmadre el último + if(((ss[nsec].cost_ac-cost_med)>0))//si está en modo fijar jornada, tampoco queremos que se desmadre el último { aux=cost_med; if(aux>cost_max) @@ -6728,15 +6887,15 @@ double Colv_limp_thr::dame_mima(int nsec, Info_sec *ss, double *mini) double dd; - //calcula la desviación típica + //calcula la desviación típica for(j=0;jcostmax) costmax=dd; if (dd &cost_amb, BYTE* st ) { @@ -6793,7 +6952,7 @@ BOOL Colv_limp_thr::pon_estado( int namb,int n_sec, Info_amb_sec *aa, Info_sec * for (i=0; i &cost_amb, double *cost, BOOL inicia) { @@ -6865,7 +7024,7 @@ int Colv_limp_thr::recorre_hijos( int iamb, int namb, Info_amb_sec *aa, int *iam } //************************************************************************************* /** - * Actualiza la matriz de costes de los ámbitos a otros ámbitos + * Actualiza la matriz de costes de los ámbitos a otros ámbitos */ BOOL Colv_limp_thr::actualiza_costes( int namb,int n_sec, Info_amb_sec *aa, Info_sec *ss, Matrix2d &cost_amb ) { @@ -6968,7 +7127,7 @@ double Colv_limp_thr::dame_coste( Secu_amb * sec, int ini, int fin, Info_sec *s d+=olv_limp->t_despl; } - //suma el coste de ir del ultimo ambito a la instalación + //suma el coste de ir del ultimo ambito a la instalación if(olv_limp->nod_instal>=0) d+=olv_limp->ord_sec_plan[0].ctnod[0][olv_limp->iaso[olv_limp->carto.get(s->iamb[sec[fin_old].iamb]).entity()->ref].inod[(sec[fin_old].entrada+1)%2]].dis; else @@ -6979,7 +7138,7 @@ double Colv_limp_thr::dame_coste( Secu_amb * sec, int ini, int fin, Info_sec *s //************************************************************************************* /** * Calcula el coste de desplazamiento de ir por todos los ambitos sec desde ini hasta fin - * cambiando el ámbito de pos_old como si estuviera en pos_new + * cambiando el ámbito de pos_old como si estuviera en pos_new */ double Colv_limp_thr::dame_coste_ex( Secu_amb * sec, int ini, int fin, Info_sec *s, int pos_old, int pos_new, int entrada ) { @@ -7014,7 +7173,7 @@ 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 + * Lee la sectorización que viene como info asociada en el shp de entrada */ BOOL Colv_limp_thr::lee_secto() { @@ -7030,7 +7189,7 @@ BOOL Colv_limp_thr::lee_secto() std::map> l_sec; std::map> l_secuen; - olvlog(LOG_TODO, "olv_limp_t", "Comienza lectura de sectorización"); + 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; @@ -7062,7 +7221,7 @@ BOOL Colv_limp_thr::lee_secto() } idd = dbf.leeNexRow(); - //rellena para cada sector info[i] qué ámbitos tiene + //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) @@ -7072,9 +7231,9 @@ BOOL Colv_limp_thr::lee_secto() } sector = dbf.getI(ics); - l_sec[sector].push_back(i);//va añadiendo al sector los elementos + 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 + if (secuen > 0)//se indica en qué secuencia va ese elemento { l_secuen[sector][secuen] = i; } @@ -7087,14 +7246,14 @@ BOOL Colv_limp_thr::lee_secto() } olv_limp->nsec = (int)l_sec.size(); //////////////////////////////////////// - //revisa si todos los ámbitos de todos los sectores tienen secuencia + //revisa si todos los ámbitos de todos los sectores tienen secuencia bool secuen_incompleta = false; bool secuen_vacia = true; for (std::map>::iterator it = l_secuen.begin(); it != l_secuen.end(); ++it) { if (secuen_vacia && (it->second.size() > 0)) secuen_vacia = false;//alguno de los sectores trae info de secuencia - 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 + 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; @@ -7111,18 +7270,18 @@ BOOL Colv_limp_thr::lee_secto() if (!secuen_vacia && secuen_incompleta) { //loguea error - pon_mi_msg("Se descarta información de secuencia por encontrarse elementos incompletos o repetidos"); + pon_mi_msg("Se descarta información de secuencia por encontrarse elementos incompletos o repetidos"); } //////////////////////////////////////// - //inicia los arrays para la sectorización + //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"); + 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 + //recoge los datos, revisando que estén las secuencias completas i = -1;//sector int ia = 0; for (std::map>::iterator it = l_sec.begin(); it != l_sec.end(); ++it) @@ -7140,7 +7299,7 @@ BOOL Colv_limp_thr::lee_secto() olv_limp->amb_sec[l_secuen[it->first][ia]].iseq = ia-1; } } - else //añade los elementos según los ha leído + else //añade los elementos según los ha leído { olv_limp->sec[i].iamb_ini_def = -1; for (ia = 0; ia < olv_limp->sec[i].namb; ia++) @@ -7154,7 +7313,7 @@ BOOL Colv_limp_thr::lee_secto() { olv_limp->usa_secuen = TRUE; //loguea - pon_mi_msg("Usa información de secuencia de la capa de entrada"); + pon_mi_msg("Usa información de secuencia de la capa de entrada"); } fin: @@ -7163,14 +7322,14 @@ fin: if (!ret) { - pon_mi_msg("Error en lectura de info de sectorización: %s", err_str); + 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 + * Lee la sectorización que viene como info asociada en el shp de entrada */ BOOL Colv_limp_thr::lee_secto_old() { @@ -7186,7 +7345,7 @@ BOOL Colv_limp_thr::lee_secto_old() std::map> l_sec; std::map> l_sec_; - olvlog(LOG_TODO,"olv_limp_t","Comienza lectura de sectorización"); + 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; @@ -7219,7 +7378,7 @@ BOOL Colv_limp_thr::lee_secto_old() int j; bool indica_secuen = true; idd =dbf.leeNexRow(); - //rellena para cada sector info[i] qué ámbitos tiene + //rellena para cada sector info[i] qué ámbitos tiene for(i=0;in_amb && idd==1; i++) { if(olv_limp->iaso[olv_limp->carto.get(i).entity()->ref].flgs & OLV_LIMP_FLG_AMB_NO) @@ -7232,12 +7391,12 @@ BOOL Colv_limp_thr::lee_secto_old() if (l_sec[sector].size() == 0) { //inicializa el array con -1 - //lo inicializa al número de ámbitos, no sabe a priori cuántos tendrá este sector + //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 + if (secuen > 0)//se indica en qué secuencia va ese elemento l_sec[sector][secuen] = i; else { @@ -7265,17 +7424,17 @@ BOOL Colv_limp_thr::lee_secto_old() olv_limp->nsec=(int)l_sec.size(); //////////////////////////////////////// - //inicia los arrays para la sectorización + //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"); + sprintf_s(err_str,OLV_MAX_ERR,"Error, Sin memoria para lectura de sectorización"); ret=FALSE; goto fin; } i=-1; int ia=0; - //mira cuántos sectores diferentes hay + //mira cuántos sectores diferentes hay for (std::map>::iterator it=l_sec.begin(); it!=l_sec.end(); ++it) { i++; @@ -7295,14 +7454,14 @@ fin: if(!ret) { - pon_mi_msg("Error en lectura de info de sectorización: %s",err_str); + pon_mi_msg("Error en lectura de info de sectorización: %s",err_str); } return ret; } //************************************************************************************* /** - * Calcula el número de sectores óptimo para los ámbitos dados + * Calcula el número de sectores óptimo para los ámbitos dados */ BOOL Colv_limp_thr::calcula_n_sec() { @@ -7315,7 +7474,7 @@ BOOL Colv_limp_thr::calcula_n_sec() nsec=-1; //////////////// - olvlog(LOG_TODO,"olv_limp_t","Comienza cálculo del número de sectores"); + olvlog(LOG_TODO,"olv_limp_t","Comienza cálculo del número de sectores"); pon_mi_progre(OLV_TAREA_CALC_SEC, 0); pon_mi_msg(""); err_str[0]=0; @@ -7330,40 +7489,40 @@ BOOL Colv_limp_thr::calcula_n_sec() goto fin; } - //hace la sectorización con un sector para que lo asigne por árbol + //hace la sectorización con un sector para que lo asigne por árbol if(!sectoriza_1())//rellena Info_sec { - sprintf_s(err_str,OLV_MAX_ERR,"Error en la primera sectorización"); + sprintf_s(err_str,OLV_MAX_ERR,"Error en la primera sectorización"); ret=FALSE; goto fin; } //////////////////////////////// - //calcula el coste de un sector con todos los ámbitos + //calcula el coste de un sector con todos los ámbitos cost_tot=olv_limp->sec[0].cost_ac;//calcula_cost_1sec_total(olv_limp->n_amb,olv_limp->sec,olv_limp->ias,olv_limp->conjs.n,olv_limp->cost_conj,olv_limp->ang_conj); if(cost_tot>=MAYUSCULO) { - sprintf_s(err_str,OLV_MAX_ERR,"Error en el cálculo del coste total de los ámbitos"); + sprintf_s(err_str,OLV_MAX_ERR,"Error en el cálculo del coste total de los ámbitos"); ret=FALSE; goto fin; } - //calcula el número de sectores, diviendo por el coste máximo de un sector + //calcula el número de sectores, diviendo por el coste máximo de un sector cost_sec = dame_cost_jornada(); if(cost_sec<=0) { - sprintf_s(err_str,OLV_MAX_ERR,"Tiempos de jornada, descanso y desplazamiento erróneos"); + sprintf_s(err_str,OLV_MAX_ERR,"Tiempos de jornada, descanso y desplazamiento erróneos"); ret=FALSE; goto fin; } nsec = (int)(cost_tot/cost_sec) + 1; //////////////// - olv_limp->calc_nsec=cost_sec; //se indica que el número de sectores es calculado, no impuesto + olv_limp->calc_nsec=cost_sec; //se indica que el número de sectores es calculado, no impuesto //////////////////////////////// //libera memoria olv_limp->libera_memo_secto(); - //pone el número de sectores calculado + //pone el número de sectores calculado if(nsec==1) { olv_limp->nsec =olv_limp->nsec_act = nsec; @@ -7378,7 +7537,7 @@ BOOL Colv_limp_thr::calcula_n_sec() fin: if(!ret) { - pon_mi_msg("Error en el cálculo del número de sectores: %s",err_str); + pon_mi_msg("Error en el cálculo del número de sectores: %s",err_str); } return ret; @@ -7393,8 +7552,8 @@ double Colv_limp_thr::dame_cost_jornada() } //************************************************************************************* /** - * Lanza la planificación de todos los ámbitos en un sector para calcular el coste total, y lo devuelve - * Devuelve también la secuencia de ámbitos planificada + * Lanza la planificación de todos los ámbitos en un sector para calcular el coste total, y lo devuelve + * Devuelve también la secuencia de ámbitos planificada */ double Colv_limp_thr::calcula_cost_1sec_total(int n_amb, Info_sec *ss, Djkt_ang_ady *ang_conj) { @@ -7464,17 +7623,17 @@ salir: } //************************************************************************************* /** - * Devuelve la planificación de todos los sectores, en los que calcula la ruta óptima o cercana a la óptima - * que recorre los ámbitos de dicho sector + * Devuelve la planificación de todos los sectores, en los que calcula la ruta óptima o cercana a la óptima + * que recorre los ámbitos de dicho sector */ BOOL Colv_limp_thr::planifica() { - olvlog(LOG_TODO,"olv_limp_t","Comienza planificación"); + olvlog(LOG_TODO,"olv_limp_t","Comienza planificación"); pon_mi_progre(OLV_TAREA_PLANIF, 0); pon_mi_msg(""); err_str[0]=0; - //revisa si algún sector no tiene ámbitos + //revisa si algún sector no tiene ámbitos int ns=0; for(int i=0;insec;i++) { @@ -7487,7 +7646,7 @@ BOOL Colv_limp_thr::planifica() olv_limp->plan=(Info_planif*)malloc(olv_limp->nsec*sizeof(Info_planif)); if(!olv_limp->plan) { - pon_mi_msg("Error, sin memoria en array de planificación"); + pon_mi_msg("Error, sin memoria en array de planificación"); return FALSE; } memset(olv_limp->plan,0,olv_limp->nsec*sizeof(Info_planif)); @@ -7499,7 +7658,7 @@ BOOL Colv_limp_thr::planifica() } //************************************************************************************* /** - * Devuelve la planificación del sector iésimo, que realiza el thread 'ithr' + * Devuelve la planificación del sector iésimo, que realiza el thread 'ithr' */ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) { @@ -7542,7 +7701,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) memset(secu2,0,olv_limp->conjs.n*2*sizeof(int)); nsecu2=0; ////////////////////////// - pp.id_e=OLV_TAREA_PLANIF;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_PLANIF;//manda de parámetro la tarea de la que es el progreso ic_aux=0; KK=olv_limp->tipo_ambit; sal=sig=FALSE; @@ -7552,7 +7711,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) iaux=-1; //////////////////////////////////////////////////// - //mira a ver cuántos sectores le tocan a este thread + //mira a ver cuántos sectores le tocan a este thread if(olv_limp->nsec &cost_amb) } else { - //no hace ningún sector, no hace falta + //no hace ningún sector, no hace falta is_ini=0; is_fin=0; } } else { - //hay más sectores que threads, le tocan más de uno + //hay más sectores que threads, le tocan más de uno is_desp=(int)ceil(1.0*(olv_limp->nsec)/n_subthr); is_ini= min(ithr*is_desp, olv_limp->nsec); is_fin=min((ithr+1)*is_desp,olv_limp->nsec); } ////////////////////////// if(is_fin==is_ini) - olvlog(LOG_TODO,"olv_limp_t","Subthr %02d, No Planifica ningún sector", ithr); + olvlog(LOG_TODO,"olv_limp_t","Subthr %02d, No Planifica ningún sector", ithr); else if(is_fin-is_ini-1==0) olvlog(LOG_TODO,"olv_limp_t","Subthr %02d, Planifica sector %02d", ithr,is_ini); else @@ -7594,7 +7753,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) s->cost_despl_aux=0; sig=FALSE; - //si venía secuencia en el archivo, se utiliza esa + //si venía secuencia en el archivo, se utiliza esa if (olv_limp->usa_secuen) { secu_ambi = planifica_sect_dada_secuen(s); @@ -7607,8 +7766,8 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) } else { - //si no venía, se planifica el sector - //busca el ámbito inicial de la planificiación + //si no venía, se planifica el sector + //busca el ámbito inicial de la planificiación secu_ambi = planifica_sect(s, olv_limp->ang_conj, OLV_LIMP_FACT_PERM); if (!secu_ambi) { @@ -7624,7 +7783,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) } } /////////////////////////////////////////// - //Añade la ruta de la instalación al primer punto + //Añade la ruta de la instalación al primer punto if(olv_limp->nod_instal>=0 && olv_limp->ord_sec_plan) { olv_limp->arch_dj.get_b(s->iamb[secu_ambi[0].iamb],secu_ambi[0].entrada,buf_nod); @@ -7642,7 +7801,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) ss=1; s->cost_despl_aux=olv_limp->cost_amb[s->iamb[secu_ambi[0].iamb]][s->iamb[secu_ambi[0].iamb]]; - s->cost_despl_aux+=s->t_despl[0];//el desplazamiento de la instalación al primer ámbito + s->cost_despl_aux+=s->t_despl[0];//el desplazamiento de la instalación al primer ámbito secu[0]=olv_limp->iaso[olv_limp->carto.get(s->iamb[secu_ambi[0].iamb]).entity()->ref].inod[secu_ambi[0].entrada]; //almacena el coste acumulado @@ -7677,11 +7836,11 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) ///////////////// } - if(olv_limp->tipo_ambit==OLV_AMB_LIN)//añade el coste del último ámbito si es lineal + if(olv_limp->tipo_ambit==OLV_AMB_LIN)//añade el coste del último ámbito si es lineal { secu[ss++]=olv_limp->iaso[olv_limp->carto.get(s->iamb[secu_ambi[s->namb-1].iamb]).entity()->ref].inod[(secu_ambi[s->namb-1].entrada+1)%2]; } - s->cost_despl_aux+=s->t_despl[1];//el desplazamiento del último ámbito a la instalación + s->cost_despl_aux+=s->t_despl[1];//el desplazamiento del último ámbito a la instalación if(esta_repe(secu_ambi, s->namb, FALSE)) olvlog(LOG_TODO,"olv_limp_t","Esta repe despues de planificar"); @@ -7689,7 +7848,7 @@ void Colv_limp_thr::planifica_sub_1(int ithr, Matrix2d &cost_amb) olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Planificando sector %02d, coste total %lf",ithr,is,s->cost_despl_aux); /////////////////////////////////////////// - //Ruta del último punto a la instalación + //Ruta del último punto a la instalación if(olv_limp->nod_instal>=0 && olv_limp->ord_sec_plan) { @@ -7752,13 +7911,13 @@ BOOL Colv_limp_thr::planifica_fin() //prepara los datos para guardarlos if(!genera_rut_ctrl(olv_limp->nsec, olv_limp->plan, FALSE)) { - pon_mi_msg("Errores en la generación de cartografía con ruta"); + pon_mi_msg("Errores en la generación de cartografía con ruta"); return FALSE; } //genera el listado del itinerario if(!genera_list_rut_ctrl()) { - pon_mi_msg("Errores en la generación del listado de la ruta: %s",err_str); + pon_mi_msg("Errores en la generación del listado de la ruta: %s",err_str); return FALSE; } //graba a archivo el obg @@ -7770,24 +7929,24 @@ BOOL Colv_limp_thr::planifica_fin() if(!guarda_dbf_sector(2)) { - pon_mi_msg("Errores en la generación de información asociada de sector: %s",err_str); + pon_mi_msg("Errores en la generación de información asociada de sector: %s",err_str); return FALSE; } /////////////////////////////////// ///////////////////////////////////////////// - //A continuación genera y graba los archivos de los subtramos de cada ruta + //A continuación genera y graba los archivos de los subtramos de cada ruta if(!gen_guard_subtramos()) return FALSE; /////////////////////////////////// - olvlog(LOG_TODO,"olv_limp_t","Planificación finalizada"); + olvlog(LOG_TODO,"olv_limp_t","Planificación finalizada"); return TRUE; } //************************************************************************************* /** - * Dada la secuencia de las conjunciones que sigue la ruta, genera la ruta diciendo por qué + * Dada la secuencia de las conjunciones que sigue la ruta, genera la ruta diciendo por qué * elementos de la red pasa y coloca los puntos de control */ BOOL Colv_limp_thr::genera_planif(int is, double cost_sec, int nsecu, int *secu, int tip_plan) @@ -7796,7 +7955,7 @@ BOOL Colv_limp_thr::genera_planif(int is, double cost_sec, int nsecu, int *secu, double cost_ctrl; Info_planif *pp; - olvlog(LOG_TODO,"olv_limp_t","Almacenando planificación sector %02d",is); + olvlog(LOG_TODO,"olv_limp_t","Almacenando planificación sector %02d",is); ///////////////// ipc=0; @@ -7841,7 +8000,7 @@ void Colv_limp_thr::pon_ptos_ctrl(Info_planif *pp, int npt_ctrl, double cost_ctr { if(ipcpts_ctrl[ipc].ipt=i-1; ipc++; } @@ -7858,8 +8017,8 @@ void Colv_limp_thr::pon_ptos_ctrl(Info_planif *pp, int npt_ctrl, double cost_ctr } //************************************************************************************* /** - * Dada la secuencia de las conjunciones que sigue la ruta, genera la ruta diciendo por qué - * elementos de la red pasa y coloca los puntos de control - Función auxiliar + * Dada la secuencia de las conjunciones que sigue la ruta, genera la ruta diciendo por qué + * elementos de la red pasa y coloca los puntos de control - Función auxiliar */ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int nsecu, int *secu, int tip_plan) { @@ -7893,10 +8052,10 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int memset(pp->elem,0,pp->nelem*sizeof(Info_elem_planif)); ////////////////////////////////////////////////////////////////// - //si es un único elemento + //si es un único elemento if(is_uno) { - //recorre los ámbitos buscándolo + //recorre los ámbitos buscándolo for(j=0;jcarto.getEntity(j); @@ -7929,7 +8088,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int } dt=OLV_TTO; - //añade la info del elemento + //añade la info del elemento pp->elem[0].refe=ref_j; pp->elem[0].k=0; pp->elem[0].tp = OLV_PLAN_TIP_AMB; @@ -7949,13 +8108,13 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int return FALSE; memset(ambs_sec,0,ss->namb); - //bucle para cada conjunción de la secuencia + //bucle para cada conjunción de la secuencia for(i=0;icarto.getEntity(j); @@ -7982,7 +8141,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int } if(amb_j<0 && olv_limp->iaso[ref_j].refe2>=0) { - //no es un ámbito + //no es un ámbito amb_j=olv_limp->iaso[olv_limp->iaso[ref_j].refe2].iamb; } if(amb_j<0 && !(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_NW)) @@ -7998,13 +8157,13 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int dt=OLV_DT_N; ///////////////////////////// //mira a ver si es carretera o amb para poner inw - if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_AMB) //es ámbito + if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_AMB) //es ámbito { ref_nw=olv_limp->inww_amb[amb_j+!sdire*olv_limp->n_amb].refnw; /////////////////////////////////// - //si no pertenece a los ámbitos de este sector o ya ha pasado por él, - //es que está desplazándose por él, le pone tipo nw + //si no pertenece a los ámbitos de este sector o ya ha pasado por él, + //es que está desplazándose por él, le pone tipo nw for(k=0;knamb;k++) { if(ss->iamb[k]==amb_j) @@ -8012,7 +8171,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int } if(k>=ss->namb || ambs_sec[k] || (tip_plan==OLV_PLAN_INST)) { - tp=OLV_PLAN_TIP_NW; //es la segunda vez que pasa por ahí + tp=OLV_PLAN_TIP_NW; //es la segunda vez que pasa por ahí dt=OLV_DESP; cost=ltot/olv_limp->v_despl; } @@ -8028,7 +8187,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int ambs_sec[k]=1; } } - else if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_SEG_LIN) //es segmento de ámbito + else if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_SEG_LIN) //es segmento de ámbito { if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_FIN) ref_nw=olv_limp->inww_amb[amb_j+olv_limp->n_amb].refnw; @@ -8054,7 +8213,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int dt=OLV_TTO; } } - else if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_PEAT_REP) + else if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_PEAT_REP)//peatonal desplazamiento no limpiando { tp=OLV_PLAN_TIP_AMB_PEAT_DESP; //en info0 se ha guardado la peatonal original @@ -8084,7 +8243,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int cost_parc_aux=pp->elem[nelesec-1].coste; else cost_parc_aux=0; - //añade la info del elemento + //añade la info del elemento pp->elem[nelesec].refe=ref_j; pp->elem[nelesec].k=!sdire; pp->elem[nelesec].tp = tp; @@ -8144,7 +8303,7 @@ BOOL Colv_limp_thr::comprueba_descarg(int iamb) } //************************************************************************************* /** - * Dada la secuencia de las conjunciones que sigue la ruta para ir y volver de la instalación, genera la planificación + * Dada la secuencia de las conjunciones que sigue la ruta para ir y volver de la instalación, genera la planificación */ BOOL Colv_limp_thr::genera_planif_instala(int is, int nvaciados, int ini, int fin, int *secu, int tip_viaje) { @@ -8157,9 +8316,9 @@ BOOL Colv_limp_thr::genera_planif_instala(int is, int nvaciados, int ini, int fi pp_insta = pp->planif_insta; if(!pp_insta) { - //inicializa, sólo la primera vez - //cuenta el número de veces que va a vaciar - pp->ninsta=2;//inicialmente tiene la ida y la vuelta a la instalación + //inicializa, sólo la primera vez + //cuenta el número de veces que va a vaciar + pp->ninsta=2;//inicialmente tiene la ida y la vuelta a la instalación if(nvaciados) pp->ninsta+=nvaciados*2-1; //todos los vaciados son ida y vuelta pp_insta = (Info_planif *)malloc(pp->ninsta*sizeof(Info_planif)); @@ -8172,7 +8331,7 @@ BOOL Colv_limp_thr::genera_planif_instala(int is, int nvaciados, int ini, int fi pp->planif_insta = pp_insta; } - //busca cuál le toca rellenar + //busca cuál le toca rellenar for(i=0;ininsta;i++) { if(pp_insta[i].nelem==0) @@ -8194,7 +8353,7 @@ BOOL Colv_limp_thr::genera_planif_instala(int is, int nvaciados, int ini, int fi } //************************************************************************************* /** - * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg + * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg * y en otro coloca los puntos de control */ BOOL Colv_limp_thr::genera_rut_ctrl(int ns, Info_planif *planif, BOOL tramos) @@ -8250,7 +8409,7 @@ BOOL Colv_limp_thr::genera_rut_ctrl(int ns, Info_planif *planif, BOOL tramos) for(ins=0;insninsta;ins++) { - //solo entra aquí si hay ruta a las instalaciones + //solo entra aquí si hay ruta a las instalaciones if(!genera_rut_aux(&pp->planif_insta[ins], is, TRUE,0,pp->planif_insta[ins].nelem-1)) { mal=TRUE; @@ -8277,10 +8436,10 @@ BOOL Colv_limp_thr::genera_rut_ctrl(int ns, Info_planif *planif, BOOL tramos) { isfin=0; if(i==0) - ie=0; //el punto de control primero está en el primer elemento + ie=0; //el punto de control primero está en el primer elemento else if(i==olv_limp->npts_ctrl-1) { - ie=pp->nelem-1;//el punto de control último está en el último elemento + ie=pp->nelem-1;//el punto de control último está en el último elemento isfin=1; } else @@ -8305,8 +8464,8 @@ BOOL Colv_limp_thr::genera_rut_ctrl(int ns, Info_planif *planif, BOOL tramos) } //************************************************************************************* /** - * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg - * y en otro coloca los puntos de control - Función auxiliar + * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg + * y en otro coloca los puntos de control - Función auxiliar */ BOOL Colv_limp_thr::genera_rut_aux(Info_planif *pp, int is, BOOL is_insta, int ie_ini, int ie_fin) { @@ -8360,7 +8519,7 @@ BOOL Colv_limp_thr::genera_rut_aux(Info_planif *pp, int is, BOOL is_insta, int i } pts_lin = lin.pts.ptr; - //Añadir puntos + //Añadir puntos for(i=ie_ini;i<=ie_fin;i++) { ient=olv_limp->carto.getRef(pp->elem[i].refe); @@ -8395,7 +8554,7 @@ BOOL Colv_limp_thr::genera_rut_aux(Info_planif *pp, int is, BOOL is_insta, int i { return FALSE; } - if(iolv->paths.path_res_rut); //cambiaext(path_shp,".shp",""); *(Cdir_manager::extension_archivo(path_shp)-1)=0; @@ -8483,7 +8642,7 @@ BOOL Colv_limp_thr::guarda_shp_rut_ctrl() /////////////////////////////////////////////////////// //luego graba los archivos de los puntos de control - //graba todos los sectores en un único path + //graba todos los sectores en un único path strcpy_s(path_shp,MAX_PATH,olv_limp->olv->paths.path_res_pt); //cambiaext(path_shp,".shp",""); *(Cdir_manager::extension_archivo(path_shp)-1)=0; @@ -8495,7 +8654,7 @@ BOOL Colv_limp_thr::guarda_shp_rut_ctrl() return FALSE; ///////////////////////////////////////////// - //A continuación graba los archivos de las flechas + //A continuación graba los archivos de las flechas strcpy_s(path_shp,MAX_PATH,olv_limp->olv->paths.path_res_rut); //cambiaext(path_shp,".shp",""); *(Cdir_manager::extension_archivo(path_shp)-1)=0; @@ -8506,7 +8665,7 @@ BOOL Colv_limp_thr::guarda_shp_rut_ctrl() return FALSE; ///////////////////////////////////////////// - //A continuación graba los archivos de los viajes a las instalaciones + //A continuación graba los archivos de los viajes a las instalaciones if(olv_limp->nod_instal>=0) { strcpy_s(path_shp,MAX_PATH,olv_limp->olv->paths.path_res_rut); @@ -8541,7 +8700,7 @@ BOOL Colv_limp_thr::gen_guard_subtramos() if(!genera_rut_ctrl(olv_limp->nsec, olv_limp->plan, TRUE)) { - pon_mi_msg("Errores en la generación de cartografía con ruta de los subtramos"); + pon_mi_msg("Errores en la generación de cartografía con ruta de los subtramos"); return FALSE; } @@ -8553,13 +8712,13 @@ BOOL Colv_limp_thr::gen_guard_subtramos() //combina los lineales de cada subtramo con la ida a descargar y la vuelta de descargar anterior if(ii>0 && !combina_rut_insta()) { - pon_mi_msg("Errores en la combinación de viajes con viajes a instalación"); + pon_mi_msg("Errores en la combinación de viajes con viajes a instalación"); return FALSE; } } //graba los archivos de la ruta de los sectores - //graba todos los sectores en un único path + //graba todos los sectores en un único path strcpy_s(path_shp,MAX_PATH,olv_limp->olv->paths.path_res_rut); //cambiaext(path_shp,".shp",""); *(Cdir_manager::extension_archivo(path_shp)-1)=0; @@ -8578,7 +8737,7 @@ BOOL Colv_limp_thr::gen_guard_subtramos() return FALSE; } - //guarda en los ámbitos una columna de "tramo al que pertenecen" + //guarda en los ámbitos una columna de "tramo al que pertenecen" if(!guarda_dbf_sector(3)) { pon_mi_msg("Errores al guardar la columna de viaje de cada cont"); @@ -8591,10 +8750,10 @@ BOOL Colv_limp_thr::gen_guard_subtramos() return TRUE; }//************************************************************************************* /** - * Como los viajes a instalaciones están ordenados, y los tramos también - * le corresponde a cada tramo it el viaje it y el it+1, excepto al último, que le pueden - * corresponder 3 viajes si la instalación y la descarga no son en el mismo sitio - * Además, actualiza el tiempo de los tramos + * Como los viajes a instalaciones están ordenados, y los tramos también + * le corresponde a cada tramo it el viaje it y el it+1, excepto al último, que le pueden + * corresponder 3 viajes si la instalación y la descarga no son en el mismo sitio + * Además, actualiza el tiempo de los tramos */ int Colv_limp_thr::rellena_insta_tramos() { @@ -8602,7 +8761,7 @@ int Colv_limp_thr::rellena_insta_tramos() Info_planif *pinsta; Info_tramos *tramo; - ii=0; //para saber si hace algún tramo o no + ii=0; //para saber si hace algún tramo o no for(int is=0;isnsec;is++) { nt=(int)olv_limp->tramos[is].size(); @@ -8628,7 +8787,7 @@ int Colv_limp_thr::rellena_insta_tramos() } if (nins % 2) //instala y descarga distintos si es impar { - //para el último tramo + //para el último tramo tramo = &olv_limp->tramos[is][nt-1]; //tramo->iins[0] = 2 * it; tramo->iins[1] = nins - 1; @@ -8643,7 +8802,7 @@ int Colv_limp_thr::rellena_insta_tramos() } //************************************************************************************* /** - * Añade las columnas de información a la ruta, tiempos, longitudes, y demás + * Añade las columnas de información a la ruta, tiempos, longitudes, y demás */ BOOL Colv_limp_thr::guarda_cols_ruta_tram(char *path_shp) { @@ -8655,7 +8814,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta_tram(char *path_shp) ManagerDbfGdataTable dbfmgr; GdataTable db; - //cuenta el número de sectores no vacíos + //cuenta el número de sectores no vacíos ntram=0; for(i=0;insec;i++) { @@ -8664,7 +8823,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta_tram(char *path_shp) ntram+=(int)olv_limp->tramos[i].size(); } - //añade una columna a la ruta de tiempo de ruta + //añade una columna a la ruta de tiempo de ruta strcpy_s(path_dbf,MAX_PATH,path_shp); //cambiaext(path_dbf,".shp",".dbf"); strcpy((Cdir_manager::extension_archivo(path_dbf)),"dbf"); @@ -8800,7 +8959,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta_tram(char *path_shp) for (it = 0; it < nt; it++) { tt = olv_limp->tramos[i][it].long_tr; - //para guardar en número + //para guardar en número ((double*)info)[nt_parc + it] = tt; } nt_parc += nt; @@ -8932,17 +9091,17 @@ void Colv_limp_thr::rellena_tramos() } //************************************************************************************* /** - * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg + * Dadas las rutas de los sectores, genera la ruta en una única línea en el obg * y en otro coloca los puntos de control */ BOOL Colv_limp_thr::combina_rut_insta() { - //en ob_rut ahora están todos los subtramos en orden: + //en ob_rut ahora están todos los subtramos en orden: //1 viaje del sector 1, 2 viaje del sector 1, 1 viaje del sector 2, etc - //hay que añadir al primer viaje de cada sector la ida desde instalación y la ida a descargar (y la ida a instalación - //si es un único viaje) - //al resto de viajes intermedios hay que añadirles la vuelta de descargar anterior y la ida a descargar - //al último viaje hay que añadirle la ida a descargar y la ida a instalación + //hay que añadir al primer viaje de cada sector la ida desde instalación y la ida a descargar (y la ida a instalación + //si es un único viaje) + //al resto de viajes intermedios hay que añadirles la vuelta de descargar anterior y la ida a descargar + //al último viaje hay que añadirle la ida a descargar y la ida a instalación int is=0, it=0, nt=0, i=0, npt_tot, npt, ntparc,ii; int niparc, res, nmax_pts; BOOL mal = false; @@ -8974,7 +9133,7 @@ BOOL Colv_limp_thr::combina_rut_insta() npt_tot+=npt; res++; } - //dado que junta tramos, resta para no replicar los puntos de unión + //dado que junta tramos, resta para no replicar los puntos de unión npt_tot=npt_tot-res; //////////////////////////////////////////////////////////////////// @@ -9006,7 +9165,7 @@ BOOL Colv_limp_thr::combina_rut_insta() if(ii==olv_limp->tramos[is][it].iins[0]) { - //después del primer viaje se copia el tramo de recogida + //después del primer viaje se copia el tramo de recogida npt=carto_rut.getEntity(it+ntparc).getNumberPtos(); ptos = (double (*)[3])carto_rut.getEntity(it+ntparc).getPto(0); @@ -9020,11 +9179,11 @@ BOOL Colv_limp_thr::combina_rut_insta() ////////////////////////////////////////////////////////////////////// if(!carto_rut.add(lin)) { - mal=TRUE; //entra por aquí?? + mal=TRUE; //entra por aquí?? continue; } } - niparc+=ii; //ii apunta a la última instalación del primer sector + niparc+=ii; //ii apunta a la última instalación del primer sector ntparc+=nt; } if(mal) @@ -9036,7 +9195,7 @@ BOOL Colv_limp_thr::combina_rut_insta() } //************************************************************************************* /** - * Añade las columnas de información a la ruta, tiempos, longitudes, y demás + * Añade las columnas de información a la ruta, tiempos, longitudes, y demás */ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) { @@ -9049,7 +9208,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) ManagerDbfGdataTable dbfmgr; GdataTable db; - //cuenta el número de sectores no vacíos + //cuenta el número de sectores no vacíos nsec=0; for(i=0;insec;i++) { @@ -9058,12 +9217,12 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } //////////////////////////////////// - //El coste_ac es lo mismo que el cost del último elemento de la planif - //más el de desplazamientos inicial y final y de descargas - //Para el total, hay que añadir los descansos + //El coste_ac es lo mismo que el cost del último elemento de la planif + //más el de desplazamientos inicial y final y de descargas + //Para el total, hay que añadir los descansos ///////////////////////////////////// - //añade una columna a la ruta de tiempo de ruta + //añade una columna a la ruta de tiempo de ruta strcpy_s(path_dbf,MAX_PATH,path_shp); //cambiaext(path_dbf,".shp",".dbf"); strcpy((Cdir_manager::extension_archivo(path_dbf)),"dbf"); @@ -9140,7 +9299,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } memset(info,0,nsec* OLV_SHP_SZ_CAMP_SZ); - //rellena la info de duración total + //rellena la info de duración total isec_novac=0; for(i=0;insec;i++) { @@ -9173,7 +9332,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } tt += olv_limp->plan[i].m[OLV_DESP] + olv_limp->plan[i].m[OLV_TTO]; - //para guardar en número + //para guardar en número ((double*)info)[isec_novac] = tt; isec_novac++; @@ -9185,7 +9344,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } memset(info, 0, nsec * OLV_SHP_SZ_CAMP_SZ); - //rellena la info de duración de los desplazamientos + //rellena la info de duración de los desplazamientos isec_novac=0; for(i=0;insec;i++) { @@ -9216,7 +9375,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } else tt = 0; - //para guardar en número + //para guardar en número ((double*)info)[isec_novac] = tt; isec_novac++; @@ -9228,7 +9387,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } memset(info, 0, nsec* OLV_SHP_SZ_CAMP_SZ); - //rellena la info de duración de los descansos + //rellena la info de duración de los descansos isec_novac=0; for(i=0;insec;i++) { @@ -9253,7 +9412,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) if(olv_limp->sec[i].namb==0) continue; tt=olv_limp->plan[i].m[OLV_DESP]+olv_limp->plan[i].m[OLV_TTO]; - //para guardar en número + //para guardar en número ((double*)info)[isec_novac] = tt; isec_novac++; @@ -9307,7 +9466,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) if (olv_limp->sec[i].namb == 0) continue; tt = olv_limp->plan[i].m[OLV_TTO_2]; - //para guardar en número + //para guardar en número ((double*)info)[isec_novac] = tt; tipodato = GdataTable::Tdouble; isec_novac++; @@ -9322,7 +9481,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) if (olv_limp->sec[i].namb == 0) continue; tt = olv_limp->sec[i].namb; - //para guardar en número + //para guardar en número ((int*)info)[isec_novac] = tt; tipodato = GdataTable::Tint; isec_novac++; @@ -9336,7 +9495,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) if (olv_limp->sec[i].namb == 0) continue; tt = olv_limp->plan[i].m[k]; - //para guardar en número + //para guardar en número ((double*)info)[isec_novac] = tt; tipodato = GdataTable::Tdouble; isec_novac++; @@ -9416,7 +9575,7 @@ BOOL Colv_limp_thr::guarda_cols_ruta(char *path_shp) } //************************************************************************************* /** - * Añade las columnas de información a los puntos de control + * Añade las columnas de información a los puntos de control */ BOOL Colv_limp_thr::guarda_cols_ctrl(char *path_shp) { @@ -9428,7 +9587,7 @@ BOOL Colv_limp_thr::guarda_cols_ctrl(char *path_shp) ManagerDbfGdataTable dbfmgr; GdataTable db; - //cuenta el número de sectores no vacíos + //cuenta el número de sectores no vacíos nsec=0; for(i=0;insec;i++) { @@ -9436,7 +9595,7 @@ BOOL Colv_limp_thr::guarda_cols_ctrl(char *path_shp) nsec++; } - //añade una columna a los puntos de control de secuencia + //añade una columna a los puntos de control de secuencia strcpy_s(path_dbf,MAX_PATH,path_shp); //cambiaext(path_dbf,".shp",".dbf"); strcpy((Cdir_manager::extension_archivo(path_dbf)),"dbf"); @@ -9537,7 +9696,7 @@ BOOL Colv_limp_thr::guarda_cols_ctrl(char *path_shp) } //************************************************************************************* /** - * Añade las columnas de información a las rutas de viajes a la instalación + * Añade las columnas de información a las rutas de viajes a la instalación */ BOOL Colv_limp_thr::guarda_cols_insta(char *path_shp) { @@ -9549,12 +9708,12 @@ BOOL Colv_limp_thr::guarda_cols_insta(char *path_shp) ManagerDbfGdataTable dbfmgr; GdataTable db; - //añade una columna + //añade una columna strcpy_s(path_dbf,MAX_PATH,path_shp); //cambiaext(path_dbf,".shp",".dbf"); char bufAux[256]; strcpy(path_dbf, Cdir_manager::cambia_extension_archivo(path_dbf,bufAux,".dbf")); - //cuenta el número de instalaciones + //cuenta el número de instalaciones ninsta=0; for(i=0;insec;i++) { @@ -9681,7 +9840,7 @@ BOOL Colv_limp_thr::guarda_cols_insta(char *path_shp) } memset(info,0,ninsta* OLV_SHP_SZ_CAMP_SZ); - //rellena la info de duración + //rellena la info de duración ninsta_parc=0; for(i=0;insec;i++) { @@ -9744,7 +9903,7 @@ BOOL Colv_limp_thr::guarda_cols_insta(char *path_shp) //************************************************************************************* /** * Recorre la ruta y genera un listado en csv donde guarda las calles por las que va pasando la ruta - * El archivo se llama como el shape, concatenando el número de sector y L, en formato csv + * El archivo se llama como el shape, concatenando el número de sector y L, en formato csv */ BOOL Colv_limp_thr::genera_list_rut_ctrl() { @@ -9802,7 +9961,7 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl() } ////////////////////////////////////////////// - //primer punto de control e instalación + //primer punto de control e instalación if(i==0) { dame_h_m_s(olv_limp->t_ini, &h, &m, &seg); @@ -9816,7 +9975,7 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl() if (linst[0] != 0) { dame_h_m_s(olv_limp->t_ini + olv_limp->t_sal, &h, &m, &seg); - sprintf_s(fila0, 256, "%02d;%04d;%s;%s;%s;%.1f;%02d:%02d:%02d;\r\n", s + 1, ii+1, "", "", "Ida desde instalación", linst[0], h, m, seg); + sprintf_s(fila0, 256, "%02d;%04d;%s;%s;%s;%.1f;%02d:%02d:%02d;\r\n", s + 1, ii+1, "", "", "Ida desde instalación", linst[0], h, m, seg); if (!cc.escribe(fila0)) { mal = TRUE; @@ -9867,7 +10026,7 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl() dt=OLV_DESP; break; case OLV_PLAN_TIP_AMB_PEAT: - strcpy_s(observ,32,"Peatonal");//pasa al siguiente para poner tto también + strcpy_s(observ,32,"Peatonal");//pasa al siguiente para poner tto también case OLV_PLAN_TIP_AMB: case OLV_PLAN_TIP_SEG_PUN: strcpy_s(tto_desp,32,"Tratamiento"); @@ -9886,7 +10045,7 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl() 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 + //apunta a otro ámbito de la red, busca carretera int ref_nw = pp->elem[i].ref_nw; BOOL sdire=false; int nveces = 0; @@ -9906,17 +10065,17 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl() if (calle[0] == 0) { - //si no ha encontrado nombre de calle y tiene guardado el último, lo copia + //si no ha encontrado nombre de calle y tiene guardado el último, lo copia if(calle_ultima[0] != 0) strcpy_s(calle, 1024, calle_ultima); } else { - //se guarda la última calle para usarla si la siguiente no encuentra nombre + //se guarda la última calle para usarla si la siguiente no encuentra nombre strcpy_s(calle_ultima, 1024, calle); } - tt=pp->elem[i].coste+t0; //a todos los costes de la ruta se añade el tiempo de desplazamiento + tt=pp->elem[i].coste+t0; //a todos los costes de la ruta se añade el tiempo de desplazamiento ltot=ltot0+pp->elem[i].ltot; ltot0=0; lttt+=pp->elem[i].ltot; @@ -9978,7 +10137,7 @@ ctrl: //ii++; } ////////////////////////////////////////////// - //último punto de control e instalación + //último punto de control e instalación if((i==(pp->nelem))&& !mal) { //quita_t_ult_desc(s,&tt); @@ -9992,7 +10151,7 @@ ctrl: pp->pts_ctrl[olv_limp->npts_ctrl-2].cost = tt; ////////////////////////////////////////////// - //último viaje a vaciar + //último viaje a vaciar if(olv_limp->iaso[pp->elem[i-1].refe].flgs & OLV_LIMP_FLG_SEG_PUN) { if(!genera_list_fila_vaci(&cc, fila0,pp->elem[i-1].refe, s,ii,tt, &t0,TRUE)) @@ -10008,7 +10167,7 @@ ctrl: if (linst[1] != 0) { dame_h_m_s(tt, &h, &m, &seg); - sprintf_s(fila0, 256, "%02d;%04d;%s;%s;%s;%.1f;%02d:%02d:%02d;\r\n", s + 1, ii, "", "", "Vuelta a instalación", linst[1], h, m, seg); + sprintf_s(fila0, 256, "%02d;%04d;%s;%s;%s;%.1f;%02d:%02d:%02d;\r\n", s + 1, ii, "", "", "Vuelta a instalación", linst[1], h, m, seg); if (!cc.escribe(fila0)) { mal = TRUE; @@ -10040,7 +10199,7 @@ ctrl: } //************************************************************************************* /** - * Quita al tiempo total el del último desplazamiento y la última descarga, solo para reco + * Quita al tiempo total el del último desplazamiento y la última descarga, solo para reco */ void Colv_limp_thr::quita_t_ult_desc(int s, double *t) { @@ -10048,7 +10207,7 @@ void Colv_limp_thr::quita_t_ult_desc(int s, double *t) } //************************************************************************************* /** - * Añade una línea al listado csv con el viaje a vaciar y vuelta + * Añade una línea al listado csv con el viaje a vaciar y vuelta */ void Colv_limp_thr::dame_h_m_s(double tt, int *h_, int *m_, int *s_) { @@ -10065,7 +10224,7 @@ void Colv_limp_thr::dame_h_m_s(double tt, int *h_, int *m_, int *s_) } //************************************************************************************* /** - * Añade una línea al listado csv con el viaje a vaciar y vuelta + * Añade una línea al listado csv con el viaje a vaciar y vuelta */ BOOL Colv_limp_thr::genera_list_fila_vaci(Colv_csv *cc, char *fila0,int ielem, int s, int ii, double tt, double *t0,BOOL is_fin) { @@ -10073,16 +10232,16 @@ BOOL Colv_limp_thr::genera_list_fila_vaci(Colv_csv *cc, char *fila0,int ielem, i } //************************************************************************************* /** - * Añade una columna de observación al listado si es contenedores + * Añade una columna de observación al listado si es contenedores */ void Colv_limp_thr::dame_observ_cont(int iamb,char *observ) { } //************************************************************************************* /** - * Modifica el dbf del shp original para poner la sectorización, - * que es el mismo que de entrada con una columna más, - * SECTOR (modo 0) o SECUENCIA VACÍA (modo 1) o SECUENCIA BUENA (modo 2) o TRAMO al que pertenece (modo 3) + * Modifica el dbf del shp original para poner la sectorización, + * que es el mismo que de entrada con una columna más, + * SECTOR (modo 0) o SECUENCIA VACÃA (modo 1) o SECUENCIA BUENA (modo 2) o TRAMO al que pertenece (modo 3) */ BOOL Colv_limp_thr::guarda_dbf_sector(int modo) { @@ -10109,7 +10268,7 @@ BOOL Colv_limp_thr::guarda_dbf_sector(int modo) case 0://sector dt= olv_limp->sec[olv_limp->amb_sec[i].sec].sec_def; break; - case 1://secuencia vacía + case 1://secuencia vacía dt=0; break; case 2://secuencia buena @@ -10128,7 +10287,7 @@ BOOL Colv_limp_thr::guarda_dbf_sector(int modo) ManagerDbfGdataTable dbfmgr; //primero graba los archivos de la ruta de los sectores - //graba todos los sectores en un único path + //graba todos los sectores en un único path strcpy_s(path_dbf,MAX_PATH,olv_limp->olv->paths.path_data); //cambiaext(path_dbf,".shp",".dbf"); strcpy((Cdir_manager::extension_archivo(path_dbf)),"dbf"); @@ -10150,8 +10309,8 @@ BOOL Colv_limp_thr::guarda_dbf_sector(int modo) //************************************************************************************* /** * 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 + * 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) { @@ -10166,8 +10325,8 @@ Secu_amb* Colv_limp_thr::planifica_sect_dada_secuen(Info_sec* s) 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 + //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) @@ -10221,7 +10380,7 @@ sal: /** * 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) - * una vez que se tenga se realizan pequeños cambios en dicho orden para ver si mejora, si es asi se deja dicho cambio como permanente + * una vez que se tenga se realizan pequeños cambios en dicho orden para ver si mejora, si es asi se deja dicho cambio como permanente * si no se quita y se intenta otro cambio */ Secu_amb * Colv_limp_thr::planifica_sect(Info_sec *s, Djkt_ang_ady *ang_conj, int npermu) @@ -10446,7 +10605,7 @@ BOOL Colv_limp_thr::busca_cercano(Info_sec *s, Secu_amb *sec, int isec, BOOL ind } //************************************************************************************* /** - * Da el ámbito inicial por el que empezar la planificación, en función del modo + * Da el ámbito inicial por el que empezar la planificación, en función del modo */ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb, short *ent/*=NULL*/) { @@ -10460,11 +10619,11 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb iaux=-1; modo=3; //////////////////////////////////////////////////// - //Coge el ámbito por defecto que se le hubiera dado en la columna secuencia - //Si no, busca el ámbito más cercano a la instalación, si la hubiera configurada, + //Coge el ámbito por defecto que se le hubiera dado en la columna secuencia + //Si no, busca el ámbito más cercano a la instalación, si la hubiera configurada, //Si no, coge el de mayor coste (modo 1) //O el de 'y+x' menor (modo 2) - //O el más alejado del centro (modo 3) + //O el más alejado del centro (modo 3) if(s->iamb_ini_def!=-1) { ient=0; @@ -10474,7 +10633,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb break; } iaux=i; - //busca el nodo más cercano a la instalación, si tiene 2 nodos y hay instalación + //busca el nodo más cercano a la instalación, si tiene 2 nodos y hay instalación if(olv_limp->tipo_ambit==OLV_AMB_LIN && olv_limp->nod_instal>=0) { //comprueba los dos nodos @@ -10491,13 +10650,13 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb else if(olv_limp->nod_instal>=0) { aux=(float)MAYUSCULO; - //se coge de punto inicial el más cercano a la instalación + //se coge de punto inicial el más cercano a la instalación for(i=0;inamb;i++) { ref_i=olv_limp->carto.get(s->iamb[i]).entity()->ref; if(olv_limp->iaso[ref_i].flgs & OLV_LIMP_FLG_AMB_NO) continue; - //calcula la distancia de la instalación al inicio del ámbito + //calcula la distancia de la instalación al inicio del ámbito ient=0; dist=olv_limp->arch_dj.dame_dis(olv_limp->arch_dj.id_instal,0,s->iamb[i],ient); if(olv_limp->tipo_ambit==OLV_AMB_LIN) @@ -10513,7 +10672,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb } } - //calcula la distancia de la instalación al final del ámbito, y se queda con la menor + //calcula la distancia de la instalación al final del ámbito, y se queda con la menor //en caso de los puntuales, va a ser igual //busca el menor @@ -10536,7 +10695,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb ref_i=olv_limp->carto.get(s->iamb[i]).entity()->ref; if(olv_limp->iaso[ref_i].flgs & OLV_LIMP_FLG_AMB_NO) continue; - //calcula la distancia de mayor entre dos ámbitos + //calcula la distancia de mayor entre dos ámbitos for(j=0;jnamb;j++) { if(i==j) @@ -10560,7 +10719,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb { ///////////////////////////////////// ////////////////////// - //Como primer ámbito coge el más extremo + //Como primer ámbito coge el más extremo //el de menor 'y+x' aux=(float)MAYUSCULO; for(i=0;inamb;i++) @@ -10585,7 +10744,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb d=0; e=-1; nn=0; - //Como primer ámbito coge el más alejado del centro + //Como primer ámbito coge el más alejado del centro //coge la x y la y media, el centro for(i=0;inamb;i++) { @@ -10601,7 +10760,7 @@ short Colv_limp_thr::dame_planif_iamb_ini(Info_sec *s, Matrix2d &cost_amb } a=a/nn; b=b/nn; - //busca el más alejado de la x e y media + //busca el más alejado de la x e y media for(i=0;inamb;i++) { ref_i=olv_limp->carto.get(s->iamb[i]).entity()->ref; @@ -10748,7 +10907,7 @@ npermu: else return FALSE; - //mira a ver si tiene que pertmutar o no. Si un sector tiene casi todos los ámbitos, no se permuta + //mira a ver si tiene que pertmutar o no. Si un sector tiene casi todos los ámbitos, no se permuta int namb_m, nsec; if(olv_limp->n_amb>=OLV_DESV_MAX_NAMB_MIN) { @@ -10861,7 +11020,7 @@ npermu: } //************************************************************************************* /** - * Calcula el coste de los sectores mediante planificación de sus ámbitos + * Calcula el coste de los sectores mediante planificación de sus ámbitos */ BOOL Colv_limp_thr::calcula_coste_sectores( Secu_amb * ord_sec,Info_sec *ss,int n_sec, th_param_planif *thp, BOOL loguear ) { @@ -10944,7 +11103,7 @@ BOOL Colv_limp_thr::esta_repe( Secu_amb *sec, int nsec, BOOL log ) } //************************************************************************************* /** - * Escribe la info resultado de la planificación + * Escribe la info resultado de la planificación */ void Colv_limp_thr::pon_info_resul() { @@ -10962,24 +11121,24 @@ void Colv_limp_thr::pon_info_resul() if(olv_limp->olv->modo_ejec==OLV_EJEC_SECT) { - //si se ha ejecutado en modo cálculo de sectorización + //si se ha ejecutado en modo cálculo de sectorización if(olv_limp->calc_nsec>0) { - //se ha pedido proponer número de sectores óptimo + //se ha pedido proponer número de sectores óptimo sprintf_s(msg_,OLV_MAX_MSG_PROCE, - "Se ha calculado la sectorización para el número de sectores óptimo\ndada la conf. elegida, que es de %ld, de tiempos:\n", + "Se ha calculado la sectorización para el número de sectores óptimo\ndada la conf. elegida, que es de %ld, de tiempos:\n", nsec); } else { - //se ha impuesto el número de sectores - sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Se ha calculado la sectorización para %ld sectores, de tiempos:\n", + //se ha impuesto el número de sectores + sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Se ha calculado la sectorización para %ld sectores, de tiempos:\n", nsec); } } else if(olv_limp->olv->modo_ejec==OLV_EJEC_PLAN) { - sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Se ha calculado la planificación para %ld sectores, de tiempos:\n", + sprintf_s(msg_,OLV_MAX_MSG_PROCE,"Se ha calculado la planificación para %ld sectores, de tiempos:\n", nsec); } else if(olv_limp->olv->modo_ejec==OLV_EJEC_TODO) @@ -11003,7 +11162,7 @@ void Colv_limp_thr::pon_info_resul() } //************************************************************************************* /* - * Lanza los multi procesos para el cálculo de cost_amb + * Lanza los multi procesos para el cálculo de cost_amb */ BOOL Colv_limp_thr::lanza_tasks(int nthr_def/*=-1*/) { @@ -11058,7 +11217,7 @@ BOOL Colv_limp_thr::lanza_tasks(int nthr_def/*=-1*/) } //************************************************************************************* /* - * Guarda a disco la matriz de dist entre conjunciones y de ángulos + * Guarda a disco la matriz de dist entre conjunciones y de ángulos */ BOOL Colv_limp_thr::guarda_mats() { @@ -11074,7 +11233,7 @@ BOOL Colv_limp_thr::guarda_mats() } //************************************************************************************* /* - * Cada thread de los que guardan a disco la matriz de dist entre conjunciones y de ángulos + * Cada thread de los que guardan a disco la matriz de dist entre conjunciones y de ángulos */ void Colv_limp_thr::guarda_mats_sub(int ithr) { @@ -11086,7 +11245,7 @@ void Colv_limp_thr::guarda_mats_sub(int ithr) HeadCostAng hda; //////////////// - pp.id_e=OLV_TAREA_GUARD_MAT;//manda de parámetro la tarea de la que es el progreso + pp.id_e=OLV_TAREA_GUARD_MAT;//manda de parámetro la tarea de la que es el progreso nconj=olv_limp->conjs.n; //las conjunciones que va a hacer n_desp = (int)ceil(1.0*nconj/n_subthr); @@ -11101,7 +11260,7 @@ void Colv_limp_thr::guarda_mats_sub(int ithr) seg = GetTickCount(); ///////////////////////////////////// - //bucle por cada conjunción de la carto + //bucle por cada conjunción de la carto Cgarray bufer; for(ic=n_ini; icn_amb;i++) { ref_i=olv_limp->carto.get(i).entity()->ref; @@ -11244,12 +11403,12 @@ BOOL Colv_limp_thr::task_dj_escucha() //lanza las tasks //ejecuta n veces OliviaTasks, cada una va a calcular una parte de la matriz de costes entre ambitos //con sus correspondientes dijkstras y lo va a escribir en disco - //antes de eso, se han guardado en disco la matriz (o maps) de costes entre conjunciones y de ángulos entre conjunciones + //antes de eso, se han guardado en disco la matriz (o maps) de costes entre conjunciones y de ángulos entre conjunciones //////////////////////////////////////////////// int ntasks=1; pon_mi_progre(OLV_TAREA_MULTITASK, 0); - olvlog(LOG_TODO,"olv_limp_t","Comienza ejecución Multitask"); + olvlog(LOG_TODO,"olv_limp_t","Comienza ejecución Multitask"); ini_infotask(ntasks); //lanza la escucha @@ -11264,7 +11423,7 @@ BOOL Colv_limp_thr::task_dj_escucha() ////////////////////////////////////// if(!lanza_tasks(ntasks)) { - pon_mi_msg("Error al lanzar multitask para el cálculo de costes entre ámbitos"); + pon_mi_msg("Error al lanzar multitask para el cálculo de costes entre ámbitos"); return FALSE; } @@ -11312,7 +11471,7 @@ double Colv_limp_thr::Dist2d(double *pt1, double *pt2) //************************************************************************************* //************************************************************************************* /** - * Thread para cálculo multiproceso de la planificación + * Thread para cálculo multiproceso de la planificación */ UINT th_planificacion(LPVOID pp) { diff --git a/Olivia/olv_limp_thr.h b/Olivia/olv_limp_thr.h index 15e1f35..f303333 100644 --- a/Olivia/olv_limp_thr.h +++ b/Olivia/olv_limp_thr.h @@ -157,6 +157,7 @@ public: //Unión de ámbitos a la red navegable BOOL une_amb_nw(int soloi=-1); BOOL corrije_topo_nw(); + BOOL corrije_conjunciones_nw(); int is_dmin(double daux, Info_inw_dmin *inww); BOOL busca_inw_dmin(int i_amb); BOOL busca_inw_dmin_ejes(int i_amb); @@ -189,6 +190,8 @@ public: BOOL calcula_ang_conj(); void calcula_ang_conj_sub(int ithr); double dame_ang_conj(int ic, int i, int j); + double dame_ang_conj2(int ic, int i, int j); + BOOL calcula_ang_conj_fin(); void revisa_calles_cortadas(); diff --git a/OliviaTasks/OliviaTasks.cpp b/OliviaTasks/OliviaTasks.cpp index 87bfe7c..fc0d23c 100644 --- a/OliviaTasks/OliviaTasks.cpp +++ b/OliviaTasks/OliviaTasks.cpp @@ -84,6 +84,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCm app->archi.rellena_dirs_ejecucion(); strcpy_s(strtem,MAX_PATH,app->archi.path_ejecutable); Cdir_manager::dir_anterior(strtem); + //Cdir_manager::dir_anterior(app->archi.path_ejecutable); sprintf(lic.dirLic,"%s\\", strtem); sprintf(lic.dirTemp,"%s\\", app->log.path); if(!lic.cargaLicencia(NULL,NOMBRE_PRODUCTO)) diff --git a/OliviaTasks/OliviaTasks.rc b/OliviaTasks/OliviaTasks.rc index 05f70d7..00a78d9 100644 --- a/OliviaTasks/OliviaTasks.rc +++ b/OliviaTasks/OliviaTasks.rc @@ -82,8 +82,8 @@ MAINICON ICON "favicon.ico" // VS_VERSION_INFO VERSIONINFO - FILEVERSION 3,1,6,0 - PRODUCTVERSION 3,1,6,0 + FILEVERSION 3,1,7,0 + PRODUCTVERSION 3,1,7,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L @@ -100,12 +100,12 @@ BEGIN BEGIN VALUE "CompanyName", "VSM" VALUE "FileDescription", "Launcher de la aplicación Olivia" - VALUE "FileVersion", "3.1.6.0" + VALUE "FileVersion", "3.1.7.0" VALUE "InternalName", "OliviaTasks" VALUE "LegalCopyright", "OLIVIA (c) VSM 2020. All rights reserved." VALUE "OriginalFilename", "OliviaTasks.exe" VALUE "ProductName", "OliviaTasks" - VALUE "ProductVersion", "3.1.6.0" + VALUE "ProductVersion", "3.1.7.0" END END BLOCK "VarFileInfo" diff --git a/OliviaTasks/OliviaTasks.vcxproj.user b/OliviaTasks/OliviaTasks.vcxproj.user index 1622917..e9cb42b 100644 --- a/OliviaTasks/OliviaTasks.vcxproj.user +++ b/OliviaTasks/OliviaTasks.vcxproj.user @@ -13,7 +13,7 @@ ..\bin\$(IntDir) WindowsLocalDebugger - C:\Desa\v2017\Olivia\bin\$(IntDir)$(TargetFileName) + $(TargetPath) /tipo:1 /ip:192.168.2.61 /port:19995 /tout:20 /path_temp:D:\Proyectos\Olivia\Instal3.0\temp\ /path_cfgeo: /debug diff --git a/includes/Olivia/OliviaDef.cs b/includes/Olivia/OliviaDef.cs index d253e62..7b3ad6b 100644 --- a/includes/Olivia/OliviaDef.cs +++ b/includes/Olivia/OliviaDef.cs @@ -51,8 +51,8 @@ namespace OliviaDef public const int ProgrMax = 100; public const int ProgrStep = 5; public const int ParamN = 5; - public const int ParamLimpN = 46; - public const int ParamRecoN = 44; + public const int ParamLimpN = 49; + public const int ParamRecoN = 47; /* * Define el separador entre parámetros de la llamada al proceso oliviatasks */ @@ -142,6 +142,7 @@ namespace OliviaDef public const string GG_pt = "path_temp"; public const string GG_pd = "path_data"; public const string GG_pn = "path_nw"; + public const string GG_pnc = "path_cnw"; public const string GG_pcar = "path_cart"; public const string GG_pcfg = "path_cfgeo"; public const string GG_strtto = "str_tto"; @@ -162,7 +163,8 @@ namespace OliviaDef public const string GG_ais = "aislados"; public const string GG_elev = "elevacion"; public const string GG_topo = "reviTopo"; - + public const string GG_conj = "reviConj"; + public const string GG_angu = "reviAng"; /** * Define las propiedades de limpieza a enviar a oliviatasks */