Narvaling
/
Olivia_v2017
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Olivia_v2017/Olivia/olv_limp_def.h

522 lines
19 KiB
C++
Raw Blame History

#pragma once
#include <float.h>
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////
/**
* @file olv_limp_def.h
* Archivo de definiciones generales de Olivia.
*/
//Defines
#define OLV_LIMP_AMB_NW_NODEF USHRT_MAX//-1 //<Indica que no hay índice del ámbito a la carretera asignada
#define OLV_LIMP_MILIS_PROGRE 500 ///<Milisegundos cada los que se actualiza el progreso de la tarea
#define OLV_LIMP_N_DMIN_NW 3 ///<Número de carreteras que almacena más cercanas
#define OLV_LIMP_N_PTOS_MED 4 ///<Número de puntos con los que calcular distancia media entre ámbito y carretera
#define OLV_LIMP_N_PTOS_DIST 2.5 ///<Distancia entre los puntos de la media
#define OLV_LIMP_M_CONJ 32 ///<Incrementos de memoria en el array de conjunciones
#define OLV_LIMP_MAX_CAMP 32 ///<Longitud máxima de la cadena de caracteres del campo de la dbf
#define OLV_LIMP_ANCH_DEF 2.2 ///<El ancho por defecto por si hubiera algún error
#define OLV_LIMP_COST_SEGM 3 ///<El coste asignado a los segmentos de unión, en segundos
#define OLV_LIMP_VELO_CIRC_PEAT 1 ///<La velocidad de circulación en calles prohibidas y peatonales, muy bajita, en km/h
#define OLV_LIMP_VELO_DESP_PEAT 3 ///<La velocidad de desplazamiento por las réplicas de peatonales, en km/h
#define OLV_LIMP_VELO_CIRC_NW 30 ///<La velocidad de desplazamiento por la nw cuando la velo es la de las vías, en km/h
#define OLV_LIMP_VELO_DEF 10 ///<La velocidad por defecto cuando viene a 0 en la nw, en km/h
#define OLV_LIMP_GIRO_VEHIC 175 ///<El giro máximo del vehículo por defecto
#define OLV_LIMP_THR_N 1 ///<Número de threads para los cálculos multiproceso
#define OLV_LIMP_FACT_PERM 4 ///<Número de elementos contiguos para permutar
#define OLV_DESV_MAX 0.15 ///<Desviación relativa con la que deja de iterar
#define OLV_DESV_MAX_ABS_MIN 1800. ///<Desviación en segundos con la que, si es menor que esa, se deja de iterar si se cumple la relativa
#define OLV_DESV_MAX_ABS 1800. ///<Desviación en segundos con la que deja de iterar
#define OLV_DESV_MAX_NAMB 0.1 ///
#define OLV_DESV_MAX_NAMB_MIN 400 //
#define OLV_T_SLEEP_MSG 6000 ///<ms a dormir después del mensaje para que se pueda leer
#define MAX_LEN_BUF_CERCANAS 24
#define OLV_DIST_PARALELAS 0.2 ///<En metros, lo que se distancia la paralela del eje al hacer la ruta
#define OLV_DIST_MAX_AMB_NW 25 ///<En metros, la dist max deseable entre un ámbito y su inw asignado, si es más, se busca otro ámbito más cercano
#define OLV_DIST_MAX_AMB_NW_MAX 30 ///<En metros, la dist max para que se quede la unión con la nw, si no la desecha completamente
#define OLV_BARRMIX_DMAX_DESC 20
#define OLV_BARRMIX_DMED_MAX 3
#define OLV_BARRMIX_DESV_MAX 1
#define OLV_PORC_LINRECT 0.5
#define OLV_TOMTOM_PEDESTRIAN 14
#define OLV_NOMB_OID "OBJECTID"
#define OLV_SHP_SZ_CAMP_CHAR 32
#define OLV_SHP_SZ_CAMP_SZ 32 //sizeof(double)
#define OLV_DIF_MAX_MISMA_COOR 0.01
//defines para ini de configuracion campos dbf-------------------------
#define OLV_LIMP_GRUPO_DBF "CONF_CAMPOS_DBF"
#define OLV_LIMP_PARAM_OBS "Observaciones"
#define OLV_LIMP_PARAM_ANCHO "Ancho_tipo"
#define OLV_LIMP_PARAM_TIPO_AP "Tipo_ap"
#define OLV_LIMP_PARAM_TIPO_ENT "Tipo_entrada"
#define OLV_LIMP_PARAM_TIPO_ENT_APARCA "Banda_aparcamiento"
#define OLV_LIMP_PARAM_TIPO_ENT_BORD "Bordillo_Libre"
#define OLV_LIMP_PARAM_TIPO_ENT_PEATO "Entidad_peatonal"
#define OLV_LIMP_PARAM_TIPO_ENT_ACERA "Entidad_acera"
#define OLV_LIMP_PARAM_TIPO_AP_LIN "Aparcamiento_linea"
#define OLV_LIMP_PARAM_TIPO_AP_BAT "Aparcamiento_bateria"
#define OLV_LIMP_GRUPO_OTROS "OTROS_PARAM"
#define OLV_LIMP_PARAM_GIRO_VEHIC "Giro_max_vehiculo"
#define OLV_LIMP_PARAM_ANCH_DEF_PEAT "Ancho_peat_def"
#define OLV_LIMP_PARAM_ANCH_DEF_ACE "Ancho_acera_def"
#define OLV_LIMP_PARAM_ANCH_DEF_APLIN "Ancho_ap_lin_def"
#define OLV_LIMP_PARAM_ANCH_DEF_APBAT "Ancho_ap_bat_def"
#define OLV_LIMP_PARAM_ANCH_DEF_BORD "Ancho_bord_lib_def"
#define OLV_LIMP_PARAM_DESV_MAX "Desv_max"
#define OLV_LIMP_PARAM_DESV_MAX_ABS "Desv_max_abs"
//flags de la info de la inw-------------------------
#define OLV_LIMP_FLG_CIRC_FT 0x00000001 ///<Indica sentido de circulación FT , ningún flag indica sentido BOTH
#define OLV_LIMP_FLG_CIRC_TF 0x00000002 ///<Indica sentido de circulación TF
#define OLV_LIMP_FLG_CIRC_NONE 0x00000004 ///<Indica sentido de circulación NONE
#define OLV_LIMP_FLG_CIRC_NO_DOB 0x00000007 ///<Indica sentido de circulación FT+TF+NONE
#define OLV_LIMP_FLG_NW_REP 0x00000008 ///<Indica si la entidad es una réplica de calle de nw
#define OLV_LIMP_FLG_AMB 0x00000020 ///<Indica si la entidad es un ámbito, ausencia de este y el de seg indica que es nw
#define OLV_LIMP_FLG_DER 0x00000010 ///<Indica que el ámbito está a la derecha de la carretera asignada, tomado su sentido FT
#define OLV_LIMP_FLG_SEG_LIN 0x00000040 ///<Indica si la entidad es un segmento de unión con los ámbitos lineales
#define OLV_LIMP_FLG_SEG_PUN 0x00000080 ///<Indica si la entidad es un segmento de unión con los ámbitos puntuales
#define OLV_LIMP_FLG_PEAT_REP 0x00000200 ///<Indica si la entidad es un ámbito peatonal replicado
#define OLV_LIMP_FLG_EJE 0x00000800 ///<Indica si la entidad es un ámbito tipo eje de calle
#define OLV_LIMP_FLG_EJE_SEG 0x00001000 ///<Indica si la entidad es un segmento de ámbito tipo eje de calle
#define OLV_LIMP_FLG_FIN 0x00002000 ///<Indica que es final del ámbito
#define OLV_LIMP_FLG_SEG_AMB 0x00004000 ///<Indica que es segmento de unión entre ámbitos
#define OLV_LIMP_FLG_AMB_NO 0x00008000 ///<indica que el ambito no se va a usar para la secto ni planif
#define OLV_LIMP_FLG_NW 0x00010000 ///<Indica que es red navegable
#define OLV_LIMP_FLG_AMB_APA 0x00020000 ///<Indica que es aparcamiento
#define OLV_LIMP_FLG_AMB_BORD 0x00040000 ///<Indica que es bordillo
#define OLV_LIMP_FLG_AMB_ACE 0x00080000 ///<Indica que es acera
#define OLV_LIMP_FLG_AMB_PEAT 0x00100000 ///<Indica que es peatonal
#define OLV_LIMP_FLG_PEAT_SEG 0x00200000 ///<Indica segmento de peatonal
#define OLV_MAX_ERR 256
#define OLV_MAX_TAREA 256
#define OLV_MAX_MSG_PROCE 1024
#define OLV_KMH2MS 1.0*1000/3600
#define OLV_MAX_IP 32
#define OLV_MAX_COL_SHP 10
#ifndef LOG_TODO
#define LOG_TODO 1
#endif
//Flags para sectores
#define OLV_LIMP_FLG_SEC_INFO_BLOCK 0x0001 //<Indica que ese sector esta bloqueado (no se puede quitar ni poner ambitos)
#define OLV_LIMP_FLG_SEC_DISTINTO 0x0002 //<Indica que ese sector puede ser distinto a los demás para cuadrar jornadas
#define OLV_LIMP_FLG_SEC_CAMB 0x0004 //<Indica que ese sector se ha cambiado
//****************************************************
#ifndef MAYUSCULO
#define MAYUSCULO (double) 1.e+30
#endif
#ifndef MINUSCULO
#define MINUSCULO (double) 1.e-20
#endif
//****************************************************
//Enums
/**
* Para distinguir si se guardan los viajes a descargar y vuelta por separado, o junto a su recogida correspondiente
*/
enum TipoShpViaj
{
OLV_SHPRUT_SHPINST=0, //Guarda en un shp Ruta cada viaje de cada sector,
//sin incluir los viajes a instalación, que se guardan en un shp aparte
OLV_SHPRUTINST, //Guarda en un único shp cada viaje de cada sector, incluida la ida a descargar y la vuelta de la descarga anterior
//Oferta barcelona
};
/**
* Para identificar los tipos de ámbitos
*/
enum TipoAmbit
{
OLV_AMB_PUN=1, //tiene que empezar siempre en 1 porque se usa para multiplicar, y el lineal ser el 2, no cambiar!
OLV_AMB_LIN,
};
;
/**
* Para los tipos de viaje a las instalaciones
*/
enum DesplTto{
OLV_DESP,
OLV_TTO,
OLV_DT_N
};
/**
* Para identificar los tipos de atributos de circulación
*/
enum AtrCirc
{
OLV_ATR_CIRC_TF,
OLV_ATR_CIRC_FT,
OLV_ATR_CIRC_NONE,
OLV_ATR_CIRC_PEDES,
OLV_ATR_CIRC_N
};
/**
* Para identificar los tipos de atributos de tipos de entidad
*/
enum AtrTipEnt
{
OLV_ATR_NOM_TIP_ENT_AP,
OLV_ATR_NOM_TIP_ENT_BORD,
OLV_ATR_NOM_TIP_ENT_PEAT,
OLV_ATR_NOM_TIP_ENT_ACERA,
OLV_ATR_NOM_TIP_ENT_N
};
/**
* Para identificar los tipos de atributos de tipos de aparcamiento
*/
enum AtrTipAp
{
OLV_ATR_TIP_AP_LIN,
OLV_ATR_TIP_AP_BAT,
OLV_ATR_TIP_AP_N
};
/**
* Para identificar los tipos de anchos por defecto
*/
enum AnchosDef
{
OLV_ANCH_DEF_PEAT,
OLV_ANCH_DEF_ACE,
OLV_ANCH_DEF_APLIN,
OLV_ANCH_DEF_APBAT,
OLV_ANCH_DEF_BORD,
OLV_ANCH_DEF_N
};
/**
* Para identificar los tipos de atributos de tipos de elementos en la planificación
*/
enum TipElemPlan
{
OLV_PLAN_TIP_NW,
OLV_PLAN_TIP_AMB,
OLV_PLAN_TIP_AMB_PEAT,
OLV_PLAN_TIP_AMB_PEAT_DESP,
OLV_PLAN_TIP_SEG_LIN,
OLV_PLAN_TIP_SEG_PUN,
};
/**
* Para los tipos de restricciones de circulación
*/
enum TipRestr
{
OLV_RES_NO,
OLV_RES_SENTIDOS_CIRC,
OLV_RES_RECOGER_SOLO_LADO_Y_GIROS,
};
/**
* Para los tipos de viaje a las instalaciones
*/
enum ViajesInsta{
OLV_IDA_INST,
OLV_VUELTA_INST,
OLV_IDA_PLANT,
OLV_VUELTA_PLANT,
OLV_IDA_PLANT_ULT,
};
/**
* Para los tipos de llamadas a la generación de la planificación
*/
enum TiposPlan{
OLV_PLAN_NORMAL,
OLV_PLAN_INST,
OLV_PLAN_RECO,
};
//****************************************************
//****************************************************
//Structs
/**
* Nueva Estructura que contiene la información asociada de la nw
*/
typedef struct Info_aso_nw
{
double velo; //velocidad de la vía, en km/h
char *nomb; //nombre de la vía
//int refe2; //en replicas, la calle orig
}Info_aso_nw;
/**
* Nueva Estructura que contiene la información asociada de las entidades de limpieza (aceras, bordillos, peatonales...)
*/
typedef struct Info_aso_limp
{
//int refe2; //en barrido mixto, el bordillo que es equivalente
//en las peatonales replicadas, la peatonal original
double ancho; //el ancho de la entidad
}Info_aso_limp;
/**
* Nueva Estructura que contiene la información asociada de los contenedores
*/
typedef struct Info_aso_reco
{
double kg; //kg de carga en total en esa ubicación
char *id; //id en texto del contenedor para llamadas a sensores
int uds; //num de cont en esa ubicación
}Info_aso_reco;
/**
* Nueva Estructura que contiene la información asociada de la carto
* se accede como map, según la clave de la referencia de la carto, pero en los ámbitos se puede
* acceder por el i del ámbito directamente porque están los primeros en el map
*/
typedef struct Info_aso2
{
INT64 flgs; //flags
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
int refe; //referencia en la carto a ese elemento
int iamb; //índice al ámbito que es
union
{
Info_aso_nw inf_n;
Info_aso_limp inf_l;
Info_aso_reco inf_r;
};
Info_aso2()
{
reset();
};
void reset()
{
flgs=0;
iamb=-1;
inod[0]=inod[1]=oid=refe2=refe=-1;
inf_r.id=inf_n.nomb=0;
inf_n.velo=inf_l.ancho=inf_r.kg=-1;
inf_r.uds=0;
};
void del()
{
if(inf_n.nomb)
free(inf_n.nomb); //solo lo hace para este porque comparte direccion de memoria con el id de reco
inf_n.nomb=NULL;
};
}Info_aso2;
/**
* Contiene la info de los tramos de la planificación
*/
typedef struct Info_tramos
{
short ie[2]; //el ind al elemento incial y final del tramo
short iins[2]; //el ind al viaje a la inst inicial y final que corresponden a ese tramo
short namb; //el número de ámbitos del tramo
short ncont; //el número de contenedores del tramo
float long_tr; //la longitud en metros del tramo
float t_total_tr; //el tiempo total del tramo en segundos
float t_tto_tr; //el tiempo de tto en segundos del tramo
float t_ini; //el tiempo inicial del tramo
float t_fin; //el tiempo final del tramo
}Info_tramos;
/**
* Estructura que contiene la información de la carretera más cercana a un ámbito
*/
typedef struct Info_inw_dmin
{
short flgs; //<Flags, para almacenar información variada
unsigned short refamb; //<La referencia de la carto del ámbito, para cuando el array no esté ordenado por ámbito sino por inw
unsigned short ip; //<El índice al punto de la carretera donde se da la distancia mínima
unsigned short refnw; //<La referencia de la carretera (la ref de la carto), entidad de la capa nw, más cercana al ámbito dado
float dmin; //<Distancia mínima encontrada entre el ámbito y la carretera en el punto más cercano
float lamb; //<Parámetro de la recta del punto más cercano: pnw[ip] + (pnw[ip+1]-pnw[ip])*lamb
float alpha; //<Diferencia con pi/2 del ángulo que forman el ámbito con el segmento que une
//<el extremo del ámbito con la carretera elegida
double pt[3]; //<Punto de la carretera donde se da la distancia mínima al ámbito
Info_inw_dmin *inw_old; //<Para cuando reapunta
Info_inw_dmin(){reset();}
void reset(int refamb=-1)
{
refnw=0;
refamb=0;
dmin=(float)FLT_MAX;
inw_old=NULL;
ip=flgs=0;
lamb=alpha=0;
pt[0]=pt[1]=pt[2]=0;
}
}Info_inw_dmin;
/**
* Estructura que contiene la información de las carreteras que llegan a una intersección
*/
typedef struct Info_conjs_inw
{
int n; //<Número de incidencias de entidades tipo carretera en la conjunción, o -1 si es conjunción de ámbito o segmento
int refnw0; //<Índice a la primera carretera que incide, que es interesante por si sólo hay una
}Info_conjs_inw;
/**
* Estructura que contiene la información de las intersecciones
*/
typedef struct Info_conjs
{
int n; //<Tamaño del array
int m; //<Memoria reservada para el array
double (*coor)[3]; //<Array de conjunciones de la red navegable y los ámbitos, de tamaño n
Info_conjs_inw *inc; //<Array de carreteras que inciden en dicha conjunción, o -1 si es una conjunción de ámbito o segmento
}Info_conjs;
/**
* Estructura que contiene la información de los sectores
*/
typedef struct Info_sec
{
short namb; //<Número de ámbitos del sector
short *iamb; //<Array de índices de los ámbitos asignados al sector
short sec_def; //<El número de sector. Habitualmente coincide con el índice del array de sectores, excepto si se lee la secto y no empieza en 0
short flags_tem; //<Flags temporales usados para igualar setores
short iamb_ini_def; //<Índice al ámbito inicial de la planificación del sector, si se define en la columna "secuencia"
float t_despl[2]; //<Tiempos de desplazamiento de la instalación al inicio, y del final a la planta
float cost_ac; //<Coste acumulado del sector
float cost_despl_aux; //<Coste de desplazamiento auxiliar del sector (para almacenar medio, mínimo, máximo..)
float dis_med; //<Distancia media entre ambitos del sector y su ambito central
float *cost_amb_sec; //<Array de distancias del sector a todos los ámbitos
float *cost_amb_sec_aux; //<Array de distancias del sector a todos los ámbitos, ponderado con las distancias al resto de sectores
}Info_sec;
/**
* Estructura que contiene la información de los ámbitos en los sectores
*/
typedef struct Info_amb_sec
{
short sec; //<Sector al que pertenece el ámbito
short iseq; //<Secuencia con la que se recorre el ámbito en su sector
short namb_cerca; //indica numero de ambitos cerca de este
short res;
int iamb_cerca[MAX_LEN_BUF_CERCANAS];
float t; //<Tiempo de trabajo acumulado hasta este ámbito dentro del sector
}Info_amb_sec;
/**
* Estructura que contiene la informacion de cada ambito correspondiente para poder recostruir el estado de sectorizacion
*/
typedef struct Info_est_amb
{
short sec; //<Sector al que pertenece el ámbito
short iseq; //<Secuencia con la que se recorre el ámbito en su sector
float t; //<Tiempo de trabajo acumulado hasta este ámbito dentro del sector
}Info_est_amb;
/**
* Estructura que contiene la información de cada elemento de la planificación.
*/
typedef struct Info_elem_planif
{
short aux; //<Variable auxiliar, indica en recogida si es ámbito en el que se va o vuelve a descargar
int refe; //<Referencia de la línea dentro de la carto
int k; //<Indica k=0 si es entrada, k=1 si es salida
int tp; //<Tipo de elemento TipElemPlan
int ref_nw; //<referencia a qué carretera está asociado el elemento
double coste; //<Coste acumulado hasta ese elemento
double ltot; //<Longitud del elemento
}Info_elem_planif;
/**
* Estructura que contiene la información de los puntos de control de la información
*/
typedef struct Info_planif_ctrl
{
int ipt; //<Punto de la planificación tras el que está el punto de control
double cost; //<Coste acumulado hasta el punto de control
}Info_planif_ctrl;
/**
* Estructura que contiene la información de la planificación. Hay una por sector
*/
typedef struct Info_planif
{
int nelem; //<Número de elementos en la secuencia de la planificación
int ninsta; //<Número de viajes que hace a la instalación
double m[OLV_DT_N]; //<Metros de desplazamiento/tratamiento de la ruta
double t[OLV_DT_N]; //<Tiempos de desplazamiento/tratamiento de la ruta, en segundos
Info_planif_ctrl *pts_ctrl; //<Array de tamaño npts_ctrl-2 contiene índices al final de qué elemento hay un punto de control intermedio
Info_elem_planif *elem; //<Array de elementos
Info_planif *planif_insta; //<Planificaciones de los viajes que hace a las instalaciones
}Info_planif;
/**
* Estructura que contiene los nombres de los campos a leer
*/
typedef struct Campos_dbf
{
char campo_circ[OLV_LIMP_MAX_CAMP];
char campo_velo[OLV_LIMP_MAX_CAMP];
char campo_name[OLV_LIMP_MAX_CAMP];
char campo_fow[OLV_LIMP_MAX_CAMP];
char campo_obs[OLV_LIMP_MAX_CAMP];
char campo_anch[OLV_LIMP_MAX_CAMP];
char campo_tipo_ap[OLV_LIMP_MAX_CAMP];
char campo_tipo_ent[OLV_LIMP_MAX_CAMP];
char campo_secto[OLV_LIMP_MAX_CAMP];
char atr_circ[OLV_ATR_CIRC_N][OLV_LIMP_MAX_CAMP];
char atr_tip_ent[OLV_ATR_NOM_TIP_ENT_N][OLV_LIMP_MAX_CAMP];
char atr_tip_apa[OLV_ATR_TIP_AP_N][OLV_LIMP_MAX_CAMP];
}Campos_dbf;
struct Djkt_nodo;
/*
* Estructura de secuencia de ambitos usada para la planificacion
*/
typedef struct Secu_amb
{
short iamb;
short entrada;//indice a nodo entrada
short flags;
int res;
Djkt_nodo *ctnod[2];
void libera(int i, int n);
}Secu_amb;
//****************************************************************
/**
* Datos de los thead que prueban combinaciones de planificacion
*/
typedef struct th_data_planif
{
BOOL currando;
BOOL activo;
int pos[2];//utilizado en sustitucion de posiciones
double coste;//coste minimo alcanzado
Secu_amb*sec;//secuencia de coste minimo alcanzado
}th_data_planif;
class Colv_limp_thr;
/**
* Parametros de los thead que prueban combinaciones de planificacion
*/
typedef struct th_param_planif
{
BOOL pirate;//indica a los thread que hay que irse
BOOL abs;
int id_curro;//id de curro
int modo;//indica el modo de curro
long nth;//numero de thread currando
int id_th;//indica al thread el id que tiene
int namb;
int param[2];
int namb_t;//numero de ambitos totales
int milis_sleep;
th_data_planif *dth;//datos obtenidos por los thread
Secu_amb*sec;
Info_sec *s;
Colv_limp_thr* tl;
//*******************************************
void a_currar()
{
for (int i=0; i<nth; i++)
{
dth[i].currando=dth[i].activo;
}
id_curro=(id_curro+1)%1000;
};
//*******************************************
BOOL terminado()
{
for (int i=0; i<nth; i++)
{
if(dth[i].currando)
return FALSE;
}
return TRUE;
};
int dame_min()
{
int j=0;
for (int i=1; i<nth; i++)
{
if(dth[j].coste>dth[i].coste)
j=i;
}
return j;
};
}th_param_planif;
Reference in New Issue View Git Blame Copy Permalink