Narvaling
/
Olivia_v2017
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Gerardo/estandarizacion
Elena 2023-02-07 01:15:48 +01:00
parent 01f143205e
commit ad248325eb
6 changed files with 94 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Olivia/olv.cpp
View File

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

7
Olivia/olv_limp_def.h
View File

@ -550,13 +550,14 @@ typedef struct Info_aso_nw_elev
//elev[FROM] = 0 o 1
//elev[TO]=0 o 1
double inod[N_NODOS]; //almacena aquí el id de las conjunciones de la carto FROM y TO
double coord[N_NODOS][3]; //almacena aquí las coord de las conjunciones de la carto FROM y TO
bool inod_check[N_NODOS]; //almacena aquí si se ha comprobado ya ese nodo
int i_nw; //la ref de la nw
}Info_aso_nw_elev;
enum INFO_ASO_NW_ELEV
{
NO_ELEV = 0,
ELEV = 1,
MISMA_ELEV = 0,
DIST_ELEV = 1,
N_ELEV = 2
};
/*
@ -577,5 +578,5 @@ typedef struct Info_aso_conj_elev_aux
*/
typedef struct Info_aso_conj_elev
{
std::vector<Info_aso_conj_elev_aux> conj_nw; //dos maps con las entidades de la nw que están a nivel 0 y a nivel 1 en la misma conjunción
std::vector<Info_aso_conj_elev_aux> conj_nw[N_ELEV]; //dos maps con las entidades de la nw que están a nivel 0 y a nivel 1 en la misma conjunción
}Info_aso_conj_elev;

134
Olivia/olv_limp_thr.cpp
View File

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

6
Olivia/olv_limp_thr.h
View File

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

2
includes/Utiles/CartoBaseElements.h
View File

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

2
includes/Utiles/GeometryFunction.h
View File

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