simulador de trÁfico vehicular “motor de flujo …
TRANSCRIPT
1
SIMULADOR DE TRÁFICO VEHICULAR “MOTOR DE FLUJO”
JHON ALEXANDER ESTRADA
MARIO SAUCEDO GUAPI
UNIVERSIDAD SAN BUENAVENTURA FACULTAD DE INGENIERÍA DE SISTEMAS
ÁREA DE SISTEMAS E INFORMÁTICA SANTIAGO DE CALI
2012
2
SIMULADOR DE TRÁFICO VEHICULAR “MOTOR DE FLUJO”
JHON ALEXANDER ESTRADA MARIO SAUCEDO GUAPI
MONOGRAFÍA PARA OPTAR AL TÍTULO DE INGENIERO DE SISTEMAS
DIRECTORES CHRISTIAN ARIAS IRAGURI INGENIERO DE SISTEMAS
UNIVERSIDAD SAN BUENAVENTURA FACULTAD DE INGENIERÍA DE SISTEMAS
ÁREA DE SISTEMAS E INFORMÁTICA SANTIAGO DE CALI
2012
3
NOTA DE ACEPTACIÓN
-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------- Presidente del Jurado
--------------------------------------------------
Jurado
--------------------------------------------------
Jurado Santiago de Cali, Octubre 08 de 2012
4
A mis padres por su apoyo incondicional en este proceso de mi vida. A mis hermanos por estar siempre en los momentos importantes. A todos mis profesores que me brindaron día a día sus conocimientos. A mi novia por estar siempre a mi lado. A Dios por brindarme la oportunidad de estar donde estoy. A todos mil gracias. Jhon Alexander Estrada
5
A mis padres por su apoyo incondicional. A mis profesores que nos brindaron sus conocimientos en la materia. A mis amistades por estar presente en todo momento y brindarme todo su apoyo. A Dios por darme la oportunidad de vivir esta experiencia. A mis compañeros y amigos que hicieron de mi paso estudiantil una memorable experiencia. Mario Saucedo Guapi
6
AGRADECIMIENTOS
Queremos dar gracias a la Universidad San Buenaventura por brindarnos
durante estos cinco (5) años una educación integral, formándonos como
profesionales y personas de bien, al Ingeniero Luis Merchán y al ingeniero
Felipe Echeverry, por permitirnos trabajar en este proyecto, a nuestro director
de proyecto Christian Arias al apoyarnos durante este proceso final.
También queremos agradecerle a cada uno de nuestros profesores que a lo
largo de la carrera nos brindaron todos sus conocimientos en nuestra etapa
estudiantil, a nuestros padres por su apoyo incondicional y a nuestros amigos y
compañeros que nos acompañaron día a día para que este sueño fuera
alcanzable.
7
ABSTRACTO
El proyecto nace de la necesidad de mejorar la movilidad a través de un
mayor flujo vehicular presentado en puntos estratégicos de la ciudad,
planteado como un problema común que se vive a diario en las calles,
se busca desarrollar una herramienta que permite ver una simulación por
medio de un componente llamado “Motor de micro simulador”, teniendo
como objetivo generar datos determinados sobre el comportamiento del
tráfico con base en un modelo lógico, brindando una interfaz que se
conecte un sistema de visualización.
ABSTRACT
The project was born of the need to improve mobility through greater
vehicle flow presented in strategic points of the city, raised as a common
problem that is lived every day in the streets, aims to develop a tool that
allows you to view a simulation through a component called "Simulator
micro Motor", aiming to generate data on the behaviour of traffic based
on a logic model providing an interface for a display system is eventually
connected.
8
TABLA DE CONTENIDO Revisiones ..................................................................................... ¡Error! Marcador no definido. AGRADECIMIENTOS ................................................................................................................... 6 1 RESUMEN ........................................................................................................................... 10 2 INTRODUCCIÓN ................................................................................................................. 11 3 OBJETIVO GENERAL ......................................................................................................... 12
3.1 OBJETIVOS ESPECÍFICOS ........................................................................................ 12 4 DEFINICIÓN DEL PROBLEMA ........................................................................................... 13 5 REFERENTE TEÓRICO ...................................................................................................... 14
5.1 TEORÍA DE GRAFOS ................................................................................................. 14 5.2 REDES DE TRANSPORTE ......................................................................................... 15 5.3 TEORIA DE COLAS .................................................................................................... 15 5.4 MODELOS DE COLAS ................................................................................................ 15 5.5 COLAS DE TRÁFICO .................................................................................................. 16 5.6 DEFINICIÓN DE SIMULADOR .................................................................................... 17 5.7 MODELO VISTA CONTROL ....................................................................................... 18
6 PLANTEAMIENTO ESTADÍSTICO ...................................................................................... 20 7.1 Características ............................................................................................................. 25
8 TECNOLOGÍAS MODERNAS ............................................................................................. 26 9 TIPOS DE ESTUDIOS ......................................................................................................... 26
9.1 Estudios de volumen .................................................................................................... 26 9.2 Estudios de velocidad .................................................................................................. 27 9.3 Tiempos de viaje .......................................................................................................... 27 9.4 Retrasar los estudios ................................................................................................... 27 9.5 Estudios de densidad ................................................................................................... 27 9.6 Estudios de accidente .................................................................................................. 27
10 ESTADO DEL ARTE .................................................................................................... 28 11 Modelos Macroscópicos .............................................................................................. 31 12 Modelos Mesoscópico ................................................................................................. 31 13 Modelos Microscópicos ................................................................................................ 31 14 DISEÑO Y METODOLOGÍA DEL PROYECTO ........................................................... 32 15 FRONTERAS DEL SISTEMA ...................................................................................... 33 16 ACTORES DEL SISTEMA ........................................................................................... 34 17 MATRIZ DE REQUERIMIENTOS ................................................................................ 35
17.1 LISTA DE REQUERIMIENTOS ................................................................................... 36 17.2 FORMATO DE MATRIZ DE REQUERIMIENTOS ....................................................... 38
18 CASOS DE USO DEL SISTEMA ................................................................................. 45 18.1 DIAGRAMA DE CASOS DE USO DEL SISTEMA ...................................................... 45 18.2 MODELO ENTIDAD RELACIÓN ................................................................................. 47
19 Persistencia de datos ................................................................................................... 48 19.1 PRINCIPALES GENERALIDADES DE LA SIMULACIÓN .......................................... 49
20 PRINCIPALES MÉTODOS DE LA INTERFAZ GRÁFICA PARA EL MODELO .......... 51 22 LISTADO DE CASOS DE USO ................................................................................... 58 23 ANÁLISIS DEL CÓDIGO “MOTOR DE FLUJO” .......................................................... 62 24 RESULTADOS DE LA SIMULACIÓN ........................................................................ 110 25 TRABAJO DE CAMPO .............................................................................................. 113 26 RECOLECCIÓN DE INFORMACIÓN ........................................................................ 121 27 FLUJO DE ENTRADA ............................................................................................... 121 28 TRABAJOS FUTUROS .............................................................................................. 122 29 TECNOLOGÍAS APLICADAS DEL PROYECTO ...................................................... 124 GLOSARIO DE TÉRMINOS ...................................................................................................... 128 CONCLUSIONES ...................................................................................................................... 130 BIBLIOGRAFIA.......................................................................................................................... 131
9
TABLA DE IMAGENES Ilustración 1 Teoría de Grafo ....................................................................................................... 14 Ilustración 2 Modelo-Control-Vista .............................................................................................. 18 Ilustración 3 Demanda de Vehículos en Colombia ..................................................................... 23 Ilustración 4 Consumo aparente de Vehículos en Colombia ...................................................... 24 Ilustración 5 Tec –Intraf ............................................................................................................... 29 Ilustración 6 Aimsun .................................................................................................................... 30 Ilustración 7 "Barra de Herramientas" ....................................................................................... 110 Ilustración 8 "Escenario Completo Aplicativo" .......................................................................... 111 Ilustración 9 "Ejemplo de Captura de Datos" ............................................................................ 111 Ilustración 10 "Escenario Final Simulado" ................................................................................ 112 Ilustración 11 "Cruce Calle 36 con Cra 46" ............................................................................... 113 Ilustración 12 "Estados de Semaforización Calle 36 con 46” ................................................... 114 Ilustración 13 "Calle 5 con Guadalupe" ..................................................................................... 115 Ilustración 14 "Calle 10 con Carrera 66" ................................................................................... 117 Ilustración 15 "Estados De Semaforización Calle 10 con 66" ................................................... 118 Ilustración 16 "Carrera 66 con Calle 9" ..................................................................................... 119 Ilustración 17 "Estados De Semaforización Carrera 66 con Calle 9" ....................................... 120 Ilustración 18 "Foto Carrera 66 con Calle 10" ........................................................................... 120 Ilustración 19 "Reporte generado por JasperReports" .............................................................. 123
10
1 RESUMEN
El incremento del tráfico vehicular es provocado en gran medida por el
rápido aumento poblacional, lo cual genera:
1) Mayor demanda de transporte entre ellos.
2) Deficiencia en la construcción de infraestructura vial.
3) Falta de educación en los conductores.
Estos factores, ocasionan que cada día exista una mayor congestión,
largas filas de vehículos, y un mayor porcentaje de accidentalidad.
El proyecto consta de dos partes, “Motor de flujo” y “visualización
gráfica”, en la realización de este trabajo se va a enfocar en desarrollar
un motor que de soporte un 1Micro Simulador de tráfico vehicular que
mejore el tránsito en la ciudad de Cali. Con esto se busca realizar una
serie de observaciones en sitios críticos con base en un trabajo de
campo previamente obtenido con resultados reales, teniendo en cuenta
estos puntos, se analizan diferentes tipos de simuladores
(macroscópicos, microscópicos, mesoscópicos) que ayuden a plantear
los posibles problemas y soluciones referente al congestionamiento vial.
Lo que se quiere con este desarrollo es que la herramienta resultante
facilite la visualización de la simulación de tal forma que permita evaluar
diversas alternativas de situaciones concretas, lo cual ayudará a las
autoridades de tránsito a mejorar las condiciones de tráfico basados en
los datos obtenidos.
1 . Micro Simulador: es un modelo por lo general discreto que describe el comportamiento del flujo del
tráfico vehicular de manera individual y detallada, mostrandolo en una escala más pequeña para un mejor
análisis.
11
2 INTRODUCCIÓN
El sistema de tráfico vehicular se describe como un sistema complejo y
difícil de modelar, ya que intervienen muchas variables y la dinámica
entre ellas es compleja, cabe destacar como principales problemas de
movilidad, la irregularidad en la infraestructura vial, cambio de sentido en
determinadas calles, accidentalidad, tiempos de semaforización entre
otras. Esto es a causa de la intervención del factor humano, teniendo en
cuenta que él es el que responde a las condiciones del tráfico de
diversas maneras ante la misma situación, un ejemplo que se vive
diariamente es en la reacción que se tiene cuando el vehículo delantero
frena, se puede decidir por adelantar o en tal caso detenerse y esperar
que avance. La mayoría de las veces el congestionamiento vehicular en
una vía es provocado por los malos hábitos de conducción que tienen
las personas que van al volante.
Estos problemas mencionados han llevado a la sociedad a la búsqueda
de optimización, para lograr que el tráfico vehicular fluya de una mejor
manera, teniendo en cuenta puntos importantes como lo son el
congestionamiento vial y la reducción de tiempos de traslado.
En esta aplicación se estudiaron varios tipos de simulación con el fin de
implementar el adecuado basado en las características del problema y
así facilitar su proceso, se realizó un trabajo de campo para la
recolección de información en el flujo vehicular de entrada y salida en
varios tramos de las vías de la ciudad, el objetivo es tener mejor
comprensión del sistema, con una serie de valores de referencia para la
prueba del modelo. Con la información obtenida se realizan varias
12
pruebas que se logren ajustar al modelo resultante que será utilizado
para alimentar la entrada de flujo vehicular a la simulación.
3 OBJETIVO GENERAL
Desarrollar el motor de un micro simulador de tráfico vehicular que
permita modelar diferentes escenarios que brinde una mejor
comprensión del tráfico, facilitando el análisis por parte del usuario.
3.1 OBJETIVOS ESPECÍFICOS
Simular el comportamiento vial teniendo en cuenta componentes
como por ejemplo: semaforización, cruces, horas pico y número
de autos que entran y salen de un determinado punto.
Definir características básicas que influyen en el flujo de tráfico
vehicular como espaciamiento promedio entre vehículos y tiempo
de reacción entre ellos.
Definir los diferentes parámetros que se deben tener en cuenta al
momento de realizar la simulación, teniendo en cuenta sus puntos
a favor y en contra.
13
4 DEFINICIÓN DEL PROBLEMA
Este trabajo consiste en que el usuario (cliente) por medio de una
simulación planteada pueda encontrar soluciones para un problema
común como lo es el tráfico vehicular, los puntos que se deben tener en
cuenta para modelar son: la semaforización con sus tiempos y estados,
el tráfico en horas denominadas “pico”, estado de las vías de la ciudad.
Con esta serie de factores lo que se busca, es darle un mejor manejo al
tráfico que se vive a diario en las calles de Cali, teniendo en cuenta los
reportes estadísticos tomados en la simulación desde varios puntos de
vista.
La medición de las condiciones del tránsito, dan información que facilita
la toma de decisiones sobre la mejora del producto.
14
5 REFERENTE TEÓRICO
5.1 TEORÍA DE GRAFOS
...En una reciente publicación (Enciclopedia Libre Universal en Español).. “..En
matemáticas y en ciencias de la computación, la teoría de grafos2 (también
llamada teoría de las gráficas) estudia las propiedades de los grafos. Un grafo
es un conjunto, no vacío, de objetos llamados vértices (o nodos) y una
selección de pares de vértices, llamados aristas (edges) que pueden ser
orientados o no. Típicamente, un grafo se representa mediante una serie de
puntos (vértices) conectados por líneas (aristas).
Ilustración 1 Teoría de Grafo
Es de conocimiento que la teoría de grafos representa situaciones que
comúnmente se relacionan con la vida cotidiana de las personas, como por
ejemplo: redes de comunicación y redes de transporte.
2 http://enciclopedia.us.es/index.php/Teor%25C3%25ADa_de_grafos
15
5.2 REDES DE TRANSPORTE
Es posible representar mediante un grafo orientado, los flujos que circulan a
través de una red de transporte. En ciertas aplicaciones interesa determinar el
flujo máximo (de un fluido, datos, etc.) que fluye a través de una red desde un
cierto nodo s (origen) hasta otro nodo t (destino), cuando los enlaces de la red
tienen una capacidad limitada de transmisión del flujo. Una red de transporte
deberá tener uno o varios vértices origen y uno o varios vértices destino. El
resto de vértices, con semigrados interior y exterior no nulos, serán vértices de
transbordo”.
5.3 TEORIA DE COLAS
...En el siguiente articulo (“Teoría de Colas,” Enrique Gracián (2012))
comenta... “..Una cola es una línea de espera. La Teoría de Colas3, establece
modelos matemáticos para resolver el problema que plantean, buscando
encontrar la solución adecuada entre los costes del sistema y los tiempos
medios de permanencia de la cola. Normalmente ésta teoría se basa en
situaciones en donde se forman turnos de espera para la prestación de un
servicio o ejecución de un trabajo.
5.4 MODELOS DE COLAS
Algunos modelos de colas son muy sencillos y otros requieren la aplicación de
teorías matemáticas sumamente complejas. Existen muchos modelos de colas,
pero se puede hacer una primera clasificación en dos grandes grupos:
Cola determinista: aquella de la que se puede dar, a priori, una
descripción detallada. Es el modelo más simple y presupone conocidos
factores como los intervalos de tiempo de llegada y de espera. Es lo que
podríamos llamar una cola sin sorpresas.
16
Cola estocástica: una cola que no puede ser descrita sin hacer intervenir
las probabilidades. Es un modelo más realista que el anterior. En un día
lluvioso, por ejemplo, es más probable que aumenten las colas de gente
en las paradas de taxis y que disminuyan en la entrada al zoo.
En la práctica, los modelos se mueven en un amplio abanico entre los extremos
descritos por los dos anteriores. En la mayoría de las colas estocásticas se
hace necesaria la ayuda de un simulador, es decir de un programa informático
capaz de recrear el modelo real, con todas sus componentes probabilísticas,
que permita el establecimiento de un modelo comparativo.
5.5 COLAS DE TRÁFICO
Las teorías matemáticas que tratan el problema general de las colas se les han
resistido durante años las colas formadas por el tráfico de vehículos. Su
característica aleatoria, dinámica de retenciones y aceleraciones no ha
acabado por ajustarse a ningún modelo conocido, por lo que se han requerido
de nuevos planteamientos, con sus correspondientes técnicas matemáticas. El
más conocido es el modelo llamado autómata celular, conocido por ser un
sistema dinámico capaz de modelar sistemas naturales como por ejemplo, una
colección de objetos que logran interactuar unos con otros.
Este modelo se basa en programas informáticos muy sencillos en los que se
introducen un número indeterminados de vehículos virtuales en la pantalla del
ordenador, capacitados para ciertas acciones simples, como girar a la derecha
o a la izquierda, detenerse o aplicar una velocidad, obteniendo con esto
estudiar el comportamiento de la simulación. Este planteamiento ha
3 http://www.enriquegracian.com/articulos/teoria-de-colas
17
proporcionado resultados interesantes en el estudio del tráfico, ya que los
vehículos, se dedican a formar colas..”.
5.6 DEFINICIÓN DE SIMULADOR
…En una reciente publicación (Enciclopedia libre Wikipedia)…
“..Un simulador4 es un aparato, por lo general informático, que permite la
reproducción de un sistema. Los simuladores reproducen sensaciones que en
realidad no están sucediendo.
Un simulador pretende reproducir tanto las sensaciones físicas
(velocidad, aceleración, percepción del entorno) como el comportamiento de
los equipos de la máquina que se pretende simular. Para simular las
sensaciones físicas se puede recurrir a complejos mecanismos hidráulicos
comandados por potentes ordenadores que mediante modelos matemáticos
consiguen reproducir sensaciones de velocidad y aceleración. Para reproducir
el entorno exterior se emplean proyecciones de bases de datos de terreno. A
este entorno se le conoce como "Entorno Sintético".
Para simular el comportamiento de los equipos de la máquina simulada se
pueden recurrir varias técnicas. Se puede elaborar un modelo de cada equipo,
se puede utilizar el equipo real o bien se puede utilizar el mismo software que
corre en el equipo real pero haciéndolo correr en un ordenador más
convencional (y por lo tanto más barato). A esta última opción se la conoce
como "Software Rehosteado"..”
4 http://es.wikipedia.org/wiki/Simulador
18
5.7 MODELO VISTA CONTROL
...En el siguiente articulo (“Modelo Vista – Controlador Definición y
Características,” Juan Sebastián, Ingeniero de Sistemas y Telecomunicaciones
de la Universidad de Manizales (Colombia)) define... “..Modelo Vista
Controlador5 (MVC) como un patrón de arquitectura de software que separa los
datos de una aplicación, la interfaz de usuario, y la lógica de control en tres
componentes distintos. El patrón MVC se ve frecuentemente en
aplicaciones web, donde la vista es la página HTML y el código que provee de
datos dinámicos a la página, el modelo es el Sistema de Gestión de Base de
Datos y la Lógica de negocio y el controlador es el responsable de recibir los
eventos de entrada desde la vista.
Ilustración 2 Modelo-Control-Vista
La finalidad del modelo es mejorar la reusabilidad por medio del desacople
entre la vista y el modelo. Los elementos del patrón son los siguientes:
El modelo es el responsable de:
1. Acceder a la capa de almacenamiento de datos. Lo ideal es que el
modelo sea independiente del sistema de almacenamiento.
5 http://www.comusoft.com/modelo-vista-controlador-definicion-y-caracteristicas
Modelo
Vista
Control
19
2. Define las reglas de negocio (la funcionalidad del sistema). Un
ejemplo de regla puede ser: “Si la mercancía pedida no está en el
almacén, consultar el tiempo de entrega estándar del proveedor”.
3. Lleva un registro de las vistas y controladores del sistema.
4. Si estamos ante un modelo activo, notificará a las vistas los
cambios que en los datos pueda producir un agente externo (por
ejemplo, un fichero bath que actualiza los datos, un temporizador
que desencadena una inserción, etc).
El controlador es el responsable de:
1. Recibe los eventos de entrada (un clic, un cambio en un campo de
texto, etc.).
2. Contiene reglas de gestión de eventos, del tipo “SI Evento Z,
entonces Acción W”. Estas acciones pueden suponer peticiones al
modelo o a las vistas. Una de estas peticiones a las vistas puede
ser una llamada al método “Actualizar()”. Una petición al modelo
puede ser “Obtener_tiempo_de_entrega( nueva_orden_de_venta
)”.
Las vistas son responsables de:
1. Recibir datos del modelo y las muestras al usuario.
2. Tienen un registro de su controlador asociado (normalmente
porque además lo instancia).
20
3. Pueden dar el servicio de “Actualización ()”, para que sea invocado
por el controlador o por el modelo (cuando es un modelo activo
que informa de los cambios en los datos producidos por otros
agentes)..”.
6 PLANTEAMIENTO ESTADÍSTICO6
…Proexport Colombia (2012, p.3-5), descubrió que... “..Colombia es un
escenario ideal para generar una plataforma de fabricación y ensamble de
vehículos, camiones, buses y autopartes destinados a abastecer el mercado
nacional y regional.
Colombia es el cuarto mayor productor de vehículos en Latinoamérica
empleando 2,5% del personal ocupado dentro de la industria manufacturera del
país.
Esta industria en Colombia comprende la actividad de ensamblaje (vehículos
ligeros, camiones, buses y motocicletas) y la fabricación de partes y piezas
utilizadas en el ensamblaje para OEM y mercado de reposición, lo que
involucra a proveedores de insumos de otras industrias como metalmecánica,
petroquímicos (plásticos y cauchos) y textiles.
Actualmente, el país tiene un parque automotor de alrededor de 3,8 millones de
unidades de vehículos, aproximadamente el 59,5% son vehículos importados..”
6 http://www.inviertaencolombia.com.co/images/Perfil%20Automotriz_2012.pdf
21
6.1 PROBLEMA REFERENTE A LA INFRAESTRUCTURA DEL
PAÍS7
...En el siguiente articulo (“Movilidad: ¿una crisis sin solución?,” Cámara
Colombiana de la Infraestructura (2012) ) comenta... “..Colombia se urbanizó
repentinamente entre 1950 y 1960. Por recomendación del economista
canadiense Lauchlin Currie, el país tenía que volcarse urgentemente del campo
a las ciudades, creando un modelo de una ciudad capital principal y varias
ciudades intermedias alrededor. Fue así como explotaron demográficamente
ciudades como Bogotá, Medellín, Cali, Barranquilla, Bucaramanga, Cúcuta y
Pereira. Pero hubo un problema: no hubo planeación urbanística. Las ciudades
crecieron aceleradamente, pero su infraestructura de transporte no se
desarrolló de la misma manera.
Hoy las administraciones locales de estas ciudades se han dado cuenta de
este fenómeno y están intentando salirle al paso al problema, pero el inusitado
aumento del parque automotor y la necesaria construcción de obras viales que
descongestionen las ciudades, han provocado que haya una crisis de movilidad
en las principales ciudades de Colombia.
6.2 EL CASO DE CALI
“Los problemas de Cali en materia de movilidad y transporte son serios. Ahora
es muy frecuente ver en las principales vías de la ciudad los embotellamientos
que dificultan el tránsito a través de la capital del Valle”.
Los estudios de la Secretaría de Tránsito de Cali muestran que diariamente se
mueven por la ciudad más de 500 mil automotores a través de 2.000 kilómetros
de vías urbanas, la gran mayoría en regular o mal estado. Cada año se
7 http://www.infraestructura.org.co/historial/noticia9_052807.php
22
matriculan unos 38 mil vehículos en la ciudad, lo que eleva el parque actual de
carros particulares a 300 mil, lo mismo que unas 250 mil motocicletas. Además,
el 59 por ciento de los cruces semaforizados presentan un estado de
saturación que los tiene a punto de colapsar.
“Otros problemas que agravan las dificultades para el desplazamiento en Cali
es la sobreoferta de transporte público, lo que agrava aún más los problemas
que atraviesa en estos momentos la ciudad en materia de movilidad. Teniendo
en cuenta el deterioro crítico de la malla vial..”
6.3 PRODUCCIÓN Y COMPOSICIÓN DEL MERCADO EN
COLOMBIA
“..La producción de vehículos ligeros en Colombia comprende la operación de
tres ensambladoras en la actualidad: General Motors, Renault y Mazda. En el
2011, el porcentaje de participación nacional de vehículos ensamblados en el
país asciende a 40,5% (alrededor de 131.510 unidades de las 324.570).
En el caso de vehículos comerciales de carga, la producción nacional está a
cargo de General Motors e Hino. En el país solo se produce camiones de
menos de 10 toneladas de carga, no se cuenta con producción de tracto
camiones, estos son importados generalmente de México.
En el segmento de buses de pasajeros, el país cuenta con la presencia de dos
importantes ensambladoras brasileras Busscar (BusscarÔnibus S.A.) y
Superpolo (Marcopolo), empresas líderes en producción de buses articulados,
intermunicipales y padrones, principalmente para los sistemas de transporte
masivo de las principales ciudades en Colombia.
23
El mercado de vehículos en Colombia está compuesto por una participación de
producción nacional del 43% y el 57% restante es importado principalmente por
Corea del Sur, México, India, Japón, Ecuador, China y Estados Unidos.
Demanda de vehículos en Colombia 2007 – 2011
Ilustración 3 Demanda de Vehículos en Colombia
La recuperación de la industria en Colombia después de la crisis económica
mundial vislumbra al sector automotor como uno de sus pioneros. En el 2011,
el comportamiento de este sector mostró los más altos resultados en ventas,
producción y nivel de empleo en su historia. Las ventas tuvieron un año record
en unidades nuevas, cerca de 324.570 representando un incremento del 28%
con respecto al año anterior (253.869 unidades).
24
Ilustración 4 Consumo aparente de Vehículos en Colombia
La demanda de vehículos en Colombia refleja un incremento en el consumo de
vehículos ligeros con un crecimiento del 30% en 2011. Sector que alcanzó una
cifra histórica de 179.922 unidades vendidas..”
7 PROBLEMAS MODERNOS EN EL TRÁFICO8
Roger P. Roess, (2004). “TRAFFIC ENGINEERING”. Upper Saddle River, New
Jersey: Pearson Prentice Hall. Cap 4, 5, 8. Describe “..La congestión urbana
ha sido una cuestión importante teniendo en cuenta el ciclo de demanda de
transporte, no siempre es posible resolver problemas de congestión a través de
expansión de capacidad. Por lo tanto los Ingenieros de tráfico están
involucrados en el desarrollo de programas y estrategias para administrar la
demanda en tiempo y espacio y desalentar el crecimiento en caso necesario.
25
Una verdadera pregunta no es "¿Cómo cuánta capacidad es necesaria para
manejar la demanda? " sino más bien, "¿Cuántos vehículos o personas pueden
entrar en áreas congestionadas en plazos de tiempo designado?'
7.1 Características
La introducción a los estudios de tráfico es el punto de partida para la mayoría
de ingenieros ya que es fundamental tener una amplia variedad de datos e
información donde describe adecuadamente el estado actual de los sistemas,
instalaciones y tráfico.
Los ingenieros de tráfico recopilen datos por muchas razones y aplicaciones:
Administrar el sistema físico. Los inventarios físicos del sistema son siempre
elementos necesarios. Estos incluyen dispositivos de control de tráfico,
accesorios de iluminación y carreteras. Estos inventarios ayudan a evaluar los
elementos que deban ser reemplazados o reparados y en qué horario previsto.
Investigando las tendencias con el tiempo. Los ingenieros de tráfico necesitan
datos de tendencia para las necesidades futuras del transporte. Estudios
paramétricos en los volúmenes de tráfico, velocidades y densidades ayudan a
cuantificar la demanda actual y evaluar la calidad del funcionamiento de las
instalaciones.
Comprender las necesidades y opciones del público y la industria. El Ingeniero
de tráfico debe tener una buena medida de cómo y por qué la gente viaja con
fines de planificación y desarrollo. Estudios de ¿Cómo los viajeros tomar
decisiones de modo, tiempo de decisiones de viaje, y otros juicios es
8 Roger P. Roess, Elena S. Prassas, William R. McShane, “TRAFFIC ENGINEERING”. Pearson
Prentice Hall
26
fundamental para la comprensión en demanda de viajes, Relaciones básicas o
parámetros de calibración. Medidas fundamentales, como percepción reacción
de tiempo, avances y espacio en autopistas y otras instalaciones de flujo
ininterrumpido, relaciones y otros parámetros claves debe ser adecuadamente
cuantificados y calibrados.
8 TECNOLOGÍAS MODERNAS
El rápido avance de las tecnologías de la información en los últimos años ha
mejorado considerablemente el Ingeniero de tráfico debe tener la capacidad de
recopilar, resumir y analizar la información. Tecnologías como la detección,
imagen de área, procesos de identificación, comunicaciones inalámbricas,
sistemas de localización satelital, asignación de tecnologías, y similares
seguirán revolucionando tanto la cantidad y calidad de los datos que pueden
ser recogidos, almacenados y analizados.
9 TIPOS DE ESTUDIOS
Sería literalmente imposible enumerar todos los estudios en el que se
involucran ingenieros de tráfico. Algunos de los más comunes incluyen:
9.1 Estudios de volumen
Los conteos de tráfico son los más básicos estos estudios se dan en principal
medida a la demanda; prácticamente todos los aspectos de Ingeniería de
tráfico requieren volumen como entrada, incluyendo la planificación de la
carretera y diseño, las decisiones en el control y operaciones.
27
9.2 Estudios de velocidad
Las características de velocidad son fuertemente relacionadas con cuestiones
de seguridad y se necesitan para evaluar la viabilidad de la normativa vigente
de la velocidad o establecer otras nuevas de forma racional.
9.3 Tiempos de viaje
Constituyen una importante medida de calidad de servicio a los automovilistas
y pasajeros; muchos modelos de previsión de la demanda también requieren
buena y precisas medidas de tiempo de viaje.
9.4 Retrasar los estudios
Retraso es un término que tiene muchos significados, en esencia, es la parte o
partes del tiempo de viaje que los usuarios encuentran, tales como parada en
un semáforo o a causa de un accidente (obstrucción).
9.5 Estudios de densidad
La densidad se calcula a partir de mediciones de caudal y velocidad en lugares
importantes.
9.6 Estudios de accidente
Como la seguridad del tráfico es la principal responsabilidad del Ingeniero, se
debe tener en cuenta las características del accidente, con factores causales y
en ubicaciones específicas..”
28
10 ESTADO DEL ARTE
Dentro del entorno de simulación de tráfico existen varios tipos, Que fueron
objeto de estudio, para el análisis objetivo al tema planteado con respecto a
nuestro aplicativo. Se dan a conocer los más utilizados e implementados a nivel
de simuladores.
SUMO9 (Simulation of Urban MObility)
“..Es una fuente abierta, altamente portátil, de simulación microscópica de
tráfico diseñado para manejar grandes redes de carreteras..” (German
Aerospace Center, Institute of Transportation SystemsLayout based on "Three
Quarters" by "SimplyGold" 2011-2012).
TransModeler10
“..Es un potente y versátil paquete de simulación, aplicable a una amplia gama
de tareas de planeamiento y modelamiento de tráfico. Este puede simular toda
clase de redes de viales, desde autopistas hasta calles de los centros de las
ciudades, y puede analizar redes multimodales de áreas extensas con gran
detalle y fidelidad..”Construido por (© caliper TransModeler Traffic Simulation
Software).
9 http://sumo.sourceforge.net/
10 http://www.caliper.com/transmodeler/descripcion.htm
29
TEC-INTRAF11
Ilustración 5 Tec –Intraf
“..Es la herramienta líder en micro simulación que permite evaluar de manera
precisa y confiable las situaciones actuales del tráfico vehicular, así como
también proponer y validar las diversas propuestas para preparar soluciones
efectivas.
Se especializa en el desarrollo de sistemas de recolección, información,
planificación, gestión y control de tráfico vehicular, que permiten al cliente
ejercer influencia sobre las condiciones de la movilidad en tiempo real y
planificar óptimamente los cambios y acciones a implementar..” Construido por
(© Grupo InTech Solutions)
11
http://www.grupointech.com/tec-intraf/
30
AIMSUN12: Simulador de tránsito vehicular
Ilustración 6 Aimsun
“..El programa de micro simulación AIMSUN dentro de las múltiples ventajas
que ofrece algunas se enumeran a continuación:
El software Permite el desarrollo de modelos a partir de archivos cuya
extensión es .dwg (levantamientos topográficos en AUTOCAD), lo cual
facilita la elaboración de modelos geométricos de las vías.
La micro simulación permite evaluar con mucho más detalle la situación
en una o varias redes viales, y permite proponer soluciones puntuales y
adecuadas al sitio.
El ambiente de trabajo del programa es amigable al usuario y permite
implementar las soluciones que el proyecto propone de una manera
sencilla. Tales soluciones abarcan semáforos inteligentes, planes de
desviación del tránsito, cambios de circulación, planes de control de
tráfico, planes de control para los sistemas de transporte público, sistema
12
http://www.einphos.com.ve/portal/index.php?option=com_content&view=article&id=56&Itemid=68
31
de enrutamiento exclusivo entre otros..” construido por (Einphos, CA -
2009 RIF J-31272969-4).
Para poder llevar a cabo la realización del simulador, y el control del mismo, fue
necesario, entender diferentes modelos de tráfico vehicular, Roger P. Roess
(Traffic Engineering, 2004, Cap 5)13 sostuvo que “Los modelos matemáticos
que comúnmente son utilizados en el fenómeno del flujo vehicular, han llevado
a que este punto sea requisito importante cuando hablamos de la teoría del
control matemático. Existen varios tipos de modelos que han ayudado a
construir este trabajo, y se separan en tres ramas, modelos Macroscópicos,
Modelos mesoscópicos y modelos microscópicos.
11 Modelos Macroscópicos
Se caracteriza por relacionar diferentes variables que son manejadas a lo largo
del proyecto como la velocidad de vehículos, densidad en el tráfico y el flujo
vehicular. Es conocido por ser un modelo continuo.
12 Modelos Mesoscópico
Se basa en establecer por medio de métodos estadísticos los eventos que
cumple un vehículo en un determinado momento teniendo en cuenta la
posición y la velocidad de desplazamiento”.
13 Modelos Microscópicos
...En una reciente publicación (Enciclopedia libre Wikipedia).. “..Los modelos
microscópicos14 se enfocan en la descripción del comportamiento del flujo del
tráfico vehicular a través de describir las entidades discretas individuales y
13
Roger P. Roess, Elena S. Prassas, William R. McShane, “TRAFFIC ENGINEERING”. Pearson
Prentice Hall 14
http://es.wikipedia.org/wiki/Tr%C3%A1nsito_vehicular
32
atómicas que interactúan unas con otras (en este caso cada vehículo
individual). Son modelos por lo general discretos..”
14 DISEÑO Y METODOLOGÍA DEL PROYECTO
Fase Nro. Iteraciones Duración
Fase de inicio 5 3 meses
Fase de elaboración 4 2 mes
Fase de construcción 5 2 meses
Fase de transición 3 2 meses
Esta aplicación se desarrollará en lenguaje de programación java,
aplicando algunos conceptos como hilos, trabajando también con bases
de datos Oracle.
Por medio de nuestro director de proyecto, se busca iniciar desde una
aplicación que ya se ha investigado con anterioridad, lo que se desea es
continuar con el proceso y así llevarlo a su etapa final.
Fase de inicio: se dará a conocer los objetivos del proyecto, su diseño,
y las diferentes estrategias que se plantearán en la elaboración del
mismo, basándonos en los requerimientos que exige la aplicación.
Fase de elaboración: elaboración de los requerimientos, así como los
casos de uso y desarrollo del código de la aplicación.
33
Fase de construcción: arquitectura y elaboración de los diferentes
modelos que actúan en la aplicación.
Fase de transición: diseño, pruebas y ajustes finales de la aplicación.
15 FRONTERAS DEL SISTEMA
De acuerdo con los objetivos de la aplicación, se han establecido las
siguientes fronteras.
En el alcance Fuera del alcance
Crear una aplicación que permita
interactuar el usuario principal con la
máquina.
La aplicación debe funcionar bajo los
sistemas operativo Linux y Windows.
Que funcione por el momento en el
navegador Internet Explorer 9.0 y
Mozilla Firefox 16.0.
Que funcione en otros navegadores
(Ej. Safari, Chrome).
Seguridad para cuentas de usuario,
contraseñas y permisos.
Seguridad especial contra hackers.
Instalar o parchar agujeros de
seguridad en los componentes de
software utilizados.
Crear una aplicación que utilice la base
de datos independiente de la empresa.
Crear una aplicación que utilice la
información y base de datos de la
empresa.
34
16 ACTORES DEL SISTEMA
Listado de actores
Usuario Administrador del sistema
35
17 MATRIZ DE REQUERIMIENTOS
Los requerimientos funcionales nos ayudan a comprender más a fondo
el comportamiento interno de la aplicación (software), por medio de
diferentes recursos que ayudan a mostrar como la teoría y formulación
de problemas son llevados a la práctica. Interactuando con cálculos
matemáticos, manipulación de datos y otras funcionalidades específicas.
Al momento de analizar una serie de requisitos funcionales luego de
diagramar los casos de uso, ya que algunas funcionalidades y requisitos
son previos al diseño, el analista puede llegar a tener cambios por medio
de excepciones, teniendo en cuenta que el desarrollo de software es un
proceso iterativo y algunas funcionalidades son previas al diseño
establecido en los casos de uso. Estos dos elementos (casos de uso y
requerimientos) se complementan en un proceso bidireccional.
36
17.1 LISTA DE REQUERIMIENTOS
El sistema debe validar la entrada del usuario al sistema por medio de
un login y un password.
El sistema debe manejar la gestión del usuario (Crear, modificar,
consultar y eliminar).
El sistema por medio de la simulación debe almacenar las
configuraciones realizadas en el sistema.
El sistema debe asignar uno o varios usuarios para ingresar al sistema.
El sistema debe ser capaz de hacer una simulación basado en las
configuraciones del sistema donde interactúan las vías, los semáforos,
edificios y flujo vehicular.
o Por medio de esta simulación el sistema debe generar un punto
de partida de un vehículo y un punto de llegada partiendo desde
el ítem edificio.
o El sistema debe permitir identificar qué tipo de vehículo está
circulando en la simulación.
o El sistema debe permitir al usuario generar un número de
vehículos al azar teniendo en cuenta la configuración de flujo
vehicular.
o El sistema debe establecer el nivel de detalle de la simulación
(microscópico, mesoscópico, macroscópico).
37
o Por medio de la cantidad de vehículos introducidos en el sistema,
se debe identificar el espaciamiento promedio entre cada uno de
ellos.
o El sistema debe identificar por medio del tráfico vehicular el
tiempo de los semáforos (cuando realizan un cambio de rojo a
verde o viceversa).
o El sistema debe identificar el número de vehículos que entran a
hacer parte de la simulación.
o El sistema debe identificar el número de vehículos que salen de la
simulación, esto lo podemos constatar al momento de que un
vehículo llegue a su destino final (edificio).
o El sistema debe determinar la densidad del tráfico, basándose en
las “horas pico” o transito normal.
38
17.2 FORMATO DE MATRIZ DE REQUERIMIENTOS
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
1 Validar usuarios 1-media 08-10-2012 Caso de uso
Proceso.
El sistema debe solicitar al usuario un Login y un password para ingresar a la aplicación y estos serán validados contra el
sistema de seguridad.
El sistema debe verificar la validez de la contraseña y de acuerdo al usuario el sistema debe establecer las opciones a
las cuales la persona tiene acceso.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
2 Gestión de usuarios 1-media 08-10-2012 Caso de uso
Proceso.
El sistema debe permitir al usuario la creación, modificación eliminación y almacenamiento de datos.
Datos
Código, Nombre, Apellido, Login, password y tipo de usuario.
39
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
3 Configuraciones en el Sistema
1-Media 08-10-2012 Casos de Uso
Proceso.
El sistema por medio de la simulación debe permitir crear, modificar, eliminar y almacenar los datos pertinentes.
Datos
Id, simulación, Tipo de vehículos, Usuarios.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
4 Asignación de Usuarios 1-Alta 08-10-2012 Casos de Uso
Proceso. El sistema debe permitir crear, modificar, eliminar y almacenar los datos de usuarios.
40
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
5 Asignar Puntos de partida de un vehículo.
1-Alta 08-10-2012 Casos de Uso
Proceso. . El sistema debe permitir la asignación de una serie de puntos de partida destinados con el ítem “Edificio” donde saldrán
los vehículos que van a interactuar en la simulación.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
6 Asignar puntos de llegada de un vehículo
1-Alta 08-10-2012 Casos de Uso
Proceso.
El sistema debe permitir la asignación de una serie de puntos de llegada destinados con el ítem “Edificio” donde saldrán
los vehículos que van a interactuar en la simulación.
41
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
7 Identificación de tipo de vehículo.
1-Alta 08-10-2012 Casos de Uso
Proceso. El sistema debe permitir al usuario asignar un tipo de vehículo que será transitado en la simulación, con el fin de observar
las diferentes escenas que se presentan en el flujo vehicular.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
8 Generar vehículos. 1-Alta 08-10-2012 Casos de Uso
Proceso.
El sistema debe generar en la simulación un número de vehículos que se desplazaran por las diferentes calles con unos
parámetros establecidos asignados por un usuario, este proceso se hará al azar.
42
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
9 Establecer nivel de detalle de la simulación.
1-Alta 08-10-2012 Casos de Uso
Proceso.
De acuerdo a la simulación este proceso se encarga de establecer según el nivel de detalle la forma con la cual será
vista la aplicación por medio de unas configuraciones en el sistema.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
10 Identificar espaciamiento entre vehículos
1-Alta 08-10-2012 Casos de Uso
Proceso. El sistema debe generar por medio de una serie de cálculos el espacio q hay de distancia entre dos vehículos, esto con el
fin de provocar estrellones y congestión vehicular.
43
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
11 Evaluar tiempo de semaforización.
1-Alta 08-10-2012 Casos de Uso
Proceso.
El sistema debe generar en la simulación el tiempo de cambio de semáforo, de acuerdo al tráfico vehicular que se
presente en el momento, por medio de la configuración del sistema el usuario puede modificar los tiempos de cambio.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
12 Evaluar número de vehículos
1-Alta 08-10-2012 Casos de Uso
Proceso.
El sistema debe evaluar la cantidad de vehículos promedio con se encuentran circulando en las calles, dependiendo la
configuración del sistema.
44
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
13 Generar nivel de tráfico 1-Alta 08-10-2012 Casos de Uso
Proceso. El sistema debe generar de acuerdo a las especificaciones dadas por el usuario el nivel de tráfico que hay en la ciudad
teniendo en cuenta las horas pico y el tráfico normal.
ID Req.
Descripción Requerimiento ID Req. Padre
Prioridad Fecha (DD-MMM-YYYY)
Casos de Uso relacionados
14 Generar reporte de movimientos realizados en la simulación.
1-Alta 08-10-2012 Casos de Uso
Proceso. El sistema debe generar un reporte en un log que muestre cada una de los movimientos realizados en la simulación.
45
18 CASOS DE USO DEL SISTEMA
18.1 DIAGRAMA DE CASOS DE USO DEL SISTEMA
46
47
18.2 MODELO ENTIDAD RELACIÓN
48
19 Persistencia de datos
Si bien es cierto, Java permite el manejo desde cero y directamente para la
manipulación de bases de datos, lo cual se logra mediante JDBC , que permite
la manipulación directa de tablas como si de lenguaje SQL se tratara, en este
caso , por ser un aplicativo con muchas tablas y mucho más robusto se utilizará
el “mapeo” de la base de datos, lo cual se logra hacer automáticamente
mediante un aplicativo. Las clases que utilizará la modelación han sido
generadas a partir de un modelo relacional de base de datos ya implementado
(Figura 1).
En términos utilizados cuando se usa persistencia, dichas clases se denominan
Entidades. El IDE para su desarrollo será MyEclipse 10.0 y el Plug-in ORM
(Object-Relational Mapping) utilizado para la generación de las Entidades será
Hibernate. Con el mapeo generado por este aplicativo se garantiza el CRUD
(créate, retrieve, update and delete) para el modelo. Así por ejemplo, cada vez
que se cree un objeto vehículo, el mismo con todos sus atributos será
guardado en una base de datos, en su respectiva tabla. Este proceso, debido al
mapeo realizado, se hace de manera transparente y automática. Igualmente en
cualquier momento, con el fin de analizar la información, el objeto podrá ser
cargado. Diferentes consultas podrán también ser realizadas al mejor estilo de
SQL. Todo esto se hace mediante métodos específicos del ORM como save,
load y find, que ahorran tiempo de programación, disminuyen la posibilidad de
cometer errores y evitan la constante escritura de código SQL para lograr los
mismos resultados.
49
19.1 PRINCIPALES GENERALIDADES DE LA SIMULACIÓN
Para modelar el tráfico vehicular en la ciudad de Cali, es necesario conocer el
funcionamiento que cumple cada una de sus variables, teniendo como clases
principales los siguientes objetos.
Vehículo
ruta
semáforo
calle
Edificio
El objeto vehículo será el actor principal en la simulación. Uno de sus atributos
será la velocidad máxima y mínima que pueda tener. Esta velocidad y el
número de carros presentes en determinado momento en el circuito de calles a
modelar, será los que determinen la congestión vehicular en una determinada
calle. Así, si el vehículo se está desplazando demasiado lento, tendrá detrás de
sí mismo una cola de vehículos esperando que aumente la velocidad o que
llegue a un cruce de calle. Podrá tomar la decisión o no de aumentar la
velocidad en caso de que detrás de sí mismo halla demasiados vehículos.
También podrá aumentar la velocidad o disminuirla si detecta o no otro
vehículo delante de él. El objeto vehículo tendrá también dentro de sus
atributos un objeto ruta, que determinará por que calles se desplazará el
vehículo. Si un vehículo se detiene, los demás vehículos detrás de él también
lo harán. Las colisiones serán mínimas en el modelo, pero si sucederán. Esto
se logrará, lanzando una colisión aleatoria cada determinado tiempo. Una
colisión podrá ser lanzada en cualquier calle o en cualquier cruce. Un vehículo
podrá detenerse o no en mitad de un cruce, generando así una congestión
vehicular.
50
El objeto ruta, será un grafo dirigido y actuará como parámetro en la
asignación de la ruta que deberá seguir un determinado vehículo. Cada cruce
de calle será un vértice del grafo y cada calle comprenderá dos aristas dirigidas
en sentido contrario, para modelar una doble vía. Las calles con una sola vía,
constarán solamente de una arista dirigida en el grafo. La ruta en sí será
generada aleatoriamente mediante cualquiera de los algoritmos conocidos para
el recorrido de grafos. Un objeto ruta tendrá como atributo un tiempo Total
Promedio que guardará el tiempo total promedio de recorrido para una ruta en
particular.
El objeto semáforo controlará el flujo de tráfico vehicular en los cruces. Tendrá
tres estados, rojo, amarillo y verde. El estado verde, le dirá al objeto vehículo
que puede continuar su trayectoria, mientras que el estado rojo le dirá que
debe detenerse. El objeto semáforo guardará dentro de sus atributos una
variable que permita ir contando el número de vehículos que pasan por
determinado cruce, así como la hora en que pasan esos vehículos. Por lo
demás, el comportamiento de semáforo será igual al de un semáforo tradicional
en las vías.
El objeto calle será uno de los componentes que formarán la ruta por donde se
desplazará el objeto vehículo. Tendrá como atributos un cruce inicial, un cruce
final y un largo, parámetro que ayudará en el cálculo del tiempo Total Promedio
de una ruta. Uno de sus atributos será también el número de accidentes
ocurridos en su trayectoria, así como el número de vehículos que por ella
pasan. Una calle será una arista dirigida dentro del grafo que modela el mapa
de calles.
Un objeto edificio podrá servir como punto de partida y llegada para un
vehículo. Sin embargo, no necesariamente será así. Un vehículo podrá partir
desde cualquier lugar donde se le indique y podrá terminar su ruta también en
51
cualquier lugar que se le indique. Estos parámetros de partida y llegada serán
introducidos por el usuario.
Todo lo anterior se manejará utilizando la funcionalidad multi-hilos presente en
el lenguaje Java. Así, cada actor dentro de la simulación actuará por cuenta
propia, como un proceso independiente, siendo acorde con la realidad, pues
cada vehículo deberá seguir su propia ruta y tomar “sus propias decisiones” de
como desplazarse por el mapa de carreteras. Cada edificio actuará también por
sí solo, generando o no vehículos que salgan a desplazarse por el mapa.
Igualmente, todo lo anterior, junto con los aspectos secundarios, garantiza el
CRUD para el modelo, pues cada instancia de cada clase creada junto con sus
eventos y actualizaciones de estado se guardará en una base de datos y dicha
información podrá luego ser recuperada para un análisis estadístico, en un
proyecto futuro.
20 PRINCIPALES MÉTODOS DE LA INTERFAZ GRÁFICA PARA EL MODELO
El modelo correrá en un Frame que se dividirá en dos partes. En una parte se
visualizará la ejecución gráfica de la simulación y en la otra parte se colocarán
las principales opciones de ejecución del modelo así como la inserción de
parámetros. Esta será la parte “aplicativa” del modelo. Esta parte constará de
dos módulos, los cuales se podrán acceder a través de dos pestañas o
elementos de menú diferentes. Un Módulo1 contendrá las siguientes opciones
de ejecución:
Ejecutar simulación.
Detener simulación.
52
Pausar simulación.
Generar ruta.
Como opciones de inserción de parámetros para el mismo Módulo1 se tendrán
los siguientes:
Tasa de entrada de vehículos, la cual se simulará utilizando una
distribución de probabilidad apropiada.
Velocidad máxima para los vehículos.
Velocidad mínima para los vehículos.
Permitir colisiones.
Tiempo de corrida (Según escala de tiempo para el modelo).
Ruta más corta o Ruta aleatoria.
Para el Módulo2 de la parte “aplicativa” se tendrá las siguientes opciones de
consulta a la base de datos:
Número de colisiones por calle y/o cruce de calle.
Número de vehículos que pasan por un determinado semáforo.
Tiempo promedio por ruta.
53
Velocidad promedio de los vehículos en una calle determinada o por
ruta.
Número de vehículos promedio que pasan por una determinada calle.
Número de vehículos promedio en el circuito para un lapso determinado.
El menú se complementaría con estas diferentes opciones.
21 LISTA DE REPORTES EN TRABAJOS FUTUROS
Porcentaje de accidentalidad en una determinada calle.
Porcentaje número de accidentes por hora.
Porcentaje de tiempo recorrido en una ruta.
Porcentaje de número de vehículos que transitan en horas pico.
Promedio de vehículos en esperan cuando el semáforo esta en rojo.
Porcentaje del Flujo total de salida de un semáforo.
Porcentaje de vehículos que cruzan cuando el semáforo esté en
verde.
CONFIGURACIÓN MAPA (INFRAESTRUCTURA)
Capacidad máxima de vehículos en una calle.
54
Obstruir un carril.
Número de carriles en una determinada calle.
Configurar número de semáforos en una calle.
Niveles de tráfico en diferentes horas.
Configurar ubicación de los semáforos.
Crear mapas.
Eliminar mapas.
Crear cruces.
Modificar cruces.
Eliminar cruces.
Consultar cruces por nombre.
Crear calle.
Modificar calle.
Eliminar calle.
Consultar calle por nombre.
55
Crear semáforo.
Consultar un determinado semáforo.
Eliminar semáforo en un caso especial (corte de luz, daño por
robo) etc.
Crear edificio.
Modificar edificio.
Eliminar edificio.
Consultar todas las simulaciones.
Bloquear calle.
Saber cómo actuar cuando hay un accidente con respecto a una
intersección.
Configurar cantidad de retardadores (policía acostado) en un
carril.
Cuantos vehículos están almacenados en un determinado
segmento. (llegado estacionado).
56
COMPORTAMIENTO EN LA SIMULACIÓN
Configuración de accidentes en horas pico.
Determinar carriles lentos, y carriles rápidos.
Ruta más rápida y corta.
Configurar tiempos de cambio en un semáforo.
Determinar tipo de desplazamiento.
Configurar tiempos de semáforo en caso de accidentes.
Configurar Velocidad con que un vehículo da una curva.
Tiempo que tarde el vehículo en cruzar el semáforo.
Saber la velocidad mínima en una curva.
Configurar tiempo que tarda un vehículo en detenerse.
Observar las frecuencias de llegada y salida de los vehículos.
Tiempo de estado en verde (libre circulación del flujo vehicular).
Cambio de orientación en un carril.
57
Detener carro en algún punto del camino.
Configurar distancia mínima entre dos vehículos.
58
22 LISTADO DE CASOS DE USO
1 Crear Mapas.
2 Consultar mapas por Código.
3 Modificar mapa (Todos los campos con excepción del Código).
4 Eliminar mapa.
5 Consultar todos los Mapas.
6 Consultar mapa por nombre.
7 Crear Cruces.
8 Consultar Cruces por Código.
9 Modificar Cruces (Todos los campos con excepción del Código).
10 Eliminar Cruces.
11 Consultar todos los Cruces.
12 Consultar Cruces por nombre.
13 Crear Calle.
14 Consultar Calle por Código.
15 Modificar Calle (Todos los campos con excepción del Código).
16 Eliminar Calle.
17 Consultar todos los Calle.
18 Consultar Calle por nombre.
19 Crear Semáforo.
20 Consultar Semáforo por Código.
21 Modificar Semáforo (Todos los campos con excepción del Código).
22 Eliminar Semáforo.
59
23 Consultar todos los Semáforo.
24 Consultar Semáforo por nombre.
25 Crear Edificio.
26 Consultar Edificio por Código.
27 Modificar Edificio (Todos los campos con excepción del Código).
28 Eliminar Edificio.
29 Consultar todos Edificio.
30 Consultar Edificio por nombre.
31 Crear Simulación.
32 Consultar Simulación por Código.
33 Modificar Simulación (Todos los campos con excepción del Código).
34 Eliminar Simulación.
35 Consultar todos los Simulación.
36 Consultar Simulación por nombre.
37 Crear Configuración Vial.
38 Consultar Configuración Vial por Código.
39 Modificar Configuración Vial (Todos los campos con excepción del
Código).
40 Eliminar Configuración Vial.
41 Consultar todos los Configuración Vial.
42 Consultar Configuración Vial.
43 Crear Parámetros de Configuración Vial.
44 Consultar Parámetros de Configuración Vial.
45 Modificar Parámetros de Configuración Vial (Todos los campos con
excepción del código).
60
46 Eliminar Parámetros de Configuración Vial.
47 Consultar todos los Parámetros de Configuración Vial.
48 Consultar Parámetros de Configuración Vial por nombre.
49 Crear Configuración Semafórica.
50 Consultar Configuración Semafórica por Código.
51 Modificar Configuración Semafórica (Todos los campos con
excepción del Código).
52 Eliminar Configuración Semafórica.
53 Consultar todos las Configuración Semafórica.
54 Consultar Configuración Semafórica por nombre.
55 Crear Parámetros Configuración Semafórica.
56 Consultar Parámetros Configuración Semafórica por Código.
57 Modificar Parámetros Configuración Semafórica (Todos los campos
con excepción del Código).
58 Eliminar Parámetros Configuración Semafórica.
59 Consultar todos los Parámetros Configuración Semafórica.
60 Consultar Parámetros Configuración Semafórica por nombre.
61 Crear Configuración Edificio.
62 Consultar Configuración Edificio por Código.
63 Modificar Configuración Edificio (Todos los campos con excepción
del Código).
64 Eliminar Configuración Edificio.
65 Consultar toda la Configuración Edificio.
66 Consultar Configuración Edificio por nombre.
67 Crear Configuración Edificio.
61
68 Consultar Configuración Edificio por Código.
69 Modificar Configuración Edificio (Todos los campos con excepción
del Código).
70 Eliminar Configuración Edificio.
71 Consultar toda la Configuración Edificio.
72 Consultar Configuración Edificio por nombre.
73 Crear Parámetros Configuración Edificio.
74 Consultar Parámetros Configuración Edificio por Código.
75 Modificar Parámetros Configuración Edificio (Todos los campos con
excepción del Código).
76 Eliminar Parámetros Configuración Edificio.
77 Consultar todos los Parámetros Configuración Edificio.
78 Consultar Parámetros Configuración Edificio por nombre.
62
23 ANÁLISIS DEL CÓDIGO “MOTOR DE FLUJO”
A continuación se va a mostrar por medio de los paquetes desarrollados, las
diferentes clases que interactúan para el funcionamiento del aplicativo,
desplegándose en los siguientes paquetes:
Actores.
Dialogos.
Digrafos “Grafos Dirigidos”.
Guis.
Panel Digrafo.
Pojos.
Utilidades.
o Cola.
o Lista.
o Nodo.
Mapping.
Actores: son los agentes que interactúan en la simulación, los cuales tienen como clases, cruces, rutas, vehículos y grafos dirigidos.
Esta es la clase Vehículos package Actors; import java.awt.Color; import java.awt.Graphics; import java.awt.Point; import java.util.ArrayList; import Utilitary.DibujaFiguras; public class Vehiculo implements DibujaFiguras, Runnable { private double z; //posición y
63
private double z0; //posición y inicial private double vz0; //velocidad y inicial; private double x;// posición x; private double x0; //posicion x inicial; private double vx0; //velocidad x inicial ; private double velocidadInicial; private double tiempo; private boolean puedoMoverme = true; //indica si el vehiculo puede moverse private double aceleracion=0; public ArrayList<Point> ListaPuntos=new ArrayList<Point>(); public int indice=0; private double[] vectorDirector; private boolean simular=false; //indica si se corre la simulacion private boolean trazarRuta=false; //indica si se habilita el trazado de una ruta private Point punto1, punto2; public Vehiculo(){ } public void dibujar(Graphics g) { //se verifica que no se halla alcanzado el vertice final de la ruta if((ListaPuntos!=null)&&(indice<ListaPuntos.size()+1)){ g.setColor(Color.ORANGE); for(int i=0;i<ListaPuntos.size()-1;i++){ g.drawLine(ListaPuntos.get(i).x,ListaPuntos.get(i).y, ListaPuntos.get(i+1).x,ListaPuntos.get(i+1).y); } if(ListaPuntos!=null){ g.fillOval(((int) x)-4, ((int) z)-4, 8, 8);} } //g.setColor(Color.DARK_GRAY); //g.fillRect(0, 0, 1000, 1000); //g.setColor(Color.RED); //g.fillOval(ListaPuntos.get(indice).x,ListaPuntos.get(indice).y, 15, 15); //g.setColor(Color.BLUE); //g.fillOval(ListaPuntos.get(indice+1).x,ListaPuntos.get(indice+1).y, 15, 15); //verifica si se ha presionado en un punto adicional para dibujar la arista que conecta if((punto2!=null)){
64
g.setColor(Color.ORANGE); g.drawLine(punto1.x,punto1.y,punto2.x,punto2.y); punto1=punto2;// el punto1 es ahora el punto2 final que se ha trazado punto2=null; //punto2 se habilita para asignarle unas nuevas coordenadas } //g.drawLine(0, 300, 400, 300); } public void iniciarVariables(){ // evalua puntos de la ruta de par en par. z0 = ListaPuntos.get(indice).y; // z0 = valor del punto inicial en la ruta. z=z0; //JOptionPane.showMessageDialog(null, "Z= "+z); x0 = ListaPuntos.get(indice).x; //x0 = valor x del punto final en la ruta x=x0; tiempo = 0; vectorDirector=calcularVectorDirector(); calcularVelocidad(); } private double[] calcularVectorDirector() { // calcula el vector unitario que dara direccion de velocidad y posicion. int direccionX=ListaPuntos.get(indice+1).x-ListaPuntos.get(indice).x; //JOptionPane.showMessageDialog(null, "Vx = "+direccionX); int direccionY=ListaPuntos.get(indice+1).y-ListaPuntos.get(indice).y; //JOptionPane.showMessageDialog(null, "Vy = "+direccionY); double norma=Math.sqrt(Math.pow(direccionX,2)+Math.pow(direccionY, 2)); //JOptionPane.showMessageDialog(null, "norma = "+norma); double[] vectorDir = new double[2]; vectorDir[0]=direccionX/norma; vectorDir[1]=direccionY/norma; return vectorDir; } public void calcularVelocidad(){ // calcula las componentes de la velocidad en cada direccion
65
vz0 = velocidadInicial * vectorDirector[1]; //JOptionPane.showMessageDialog(null,"Vy> = "+vectorDirector[1]+"Vz0 = "+vz0); vx0 = velocidadInicial * vectorDirector[0]; //JOptionPane.showMessageDialog(null," Vx> = "+vectorDirector[0]+"Vxo = "+vx0); } public void moverse() { // si puede moverse el mismo lanza su proceso run() if (puedoMoverme) { new Thread(this).start(); } } public void run() { puedoMoverme = false; // Determina si la coordenada y del punto inicial es menor que la coordenada Y // del punto final. "Linea inclinada hacia abajo" if(ListaPuntos.get(indice).y<ListaPuntos.get(indice+1).y){ while (z < ListaPuntos.get(indice+1).y) { try { update(); Thread.sleep(60); //JOptionPane.showMessageDialog(null, "Posicion Y = "+z); //JOptionPane.showMessageDialog(null, "Posicion X = "+x); } catch (InterruptedException ex) { ex.printStackTrace(); } } //Reinicia las varibles y activa el movimiento puedoMoverme = true;
66
indice++; //JOptionPane.showMessageDialog(null,"nuevo indice = "+indice); if((indice+1)<ListaPuntos.size()+1){ iniciarVariables(); z=ListaPuntos.get(indice).y; moverse(); } } else{ // la linea esta inclinada hacia arriba. En este caso el valor Y del punto inicial // es mayor que el valor Y del punto final while (z > ListaPuntos.get(indice+1).y) { try { update(); Thread.sleep(60); //JOptionPane.showMessageDialog(null, "Posicion Y = "+z); //JOptionPane.showMessageDialog(null, "Posicion X = "+x); } catch (InterruptedException ex) { ex.printStackTrace(); } } //Reinicia las varibles y activa el movimiento puedoMoverme = true; indice++; if((indice+1)<ListaPuntos.size()+1){ iniciarVariables(); z=ListaPuntos.get(indice).y; moverse(); } } }
67
// actualiza las posiciones X y Y de la particula para cada intervalo de tiempo, para // cada repaint() public void update() { //actualizar el tiempo y la nueva posicion. double incrementoTiempo = 0.05; tiempo += incrementoTiempo; //se aplica la fórmula x= v0.cosθ.t x = x0+vx0* tiempo+0.5 * aceleracion * Math.pow(tiempo, 2); z = z0+vz0 * tiempo + 0.5 * aceleracion * Math.pow(tiempo, 2); //posicionamos el proyectil respecto a sus coordenadas iniciales. //z = 1000 - z; //JOptionPane.showMessageDialog(null,"HOLA"); velocidadInicial = 60; //JOptionPane.showMessageDialog(null, "Velocidad = "+velocidadInicial); //angulo = Integer.valueOf(textFieldAngulo.getText()); iniciarVariables(); //VehiculoDAO vehiculoDAO = new VehiculoDAO(); //vehiculoDAO.guardaVehiculo(this); moverse(); } @Override public void transladar(int tx, int ty) { // TODO Auto-generated method stub } }
Daos: Se encarga de manejar los escenarios de la simulación para la
captura de datos, las clases son callelogicadaos y crucelogicadaos.
68
import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Session; import Actors.HibernateUtil; import POJOS.Callelogica; public class calleLogicaDAO { private Session sesion; //private Transaction tx; public String guardacalleLogica(Callelogica calle) throws HibernateException { String id = "0"; try { iniciaOperacion(); id = (String) sesion.save(calle); sesion.getTransaction().commit(); //tx.commit(); } catch (HibernateException he) { manejaExcepcion(he); throw he; } finally { sesion.close(); } return id; } public void actualizacalleLogica(Callelogica calle) throws HibernateException { try { iniciaOperacion(); sesion.update(calle);
69
sesion.getTransaction().commit(); //tx.commit(); } catch (HibernateException he) { manejaExcepcion(he); throw he; } finally { sesion.close(); } } public void eliminaCalleLogica(Callelogica calle) throws HibernateException { try { iniciaOperacion(); sesion.delete(calle); sesion.getTransaction().commit(); //tx.commit(); } catch (HibernateException he) { manejaExcepcion(he); throw he; } finally { sesion.close(); } } public Callelogica obtenCallelogica(String codCalle) throws HibernateException { Callelogica calle = null; try { iniciaOperacion(); calle = (Callelogica) sesion.get(Callelogica.class, codCalle); } finally { sesion.close(); }
70
return calle; } public List<Callelogica> obtenListaCalleLogica() throws HibernateException { List<Callelogica> listaCalles = null; try { iniciaOperacion(); listaCalles = sesion.createQuery("from CalleLogica").list(); } finally { sesion.close(); } return listaCalles; } private void iniciaOperacion() throws HibernateException { sesion = HibernateUtil.getSessionFactory().openSession(); sesion.beginTransaction(); //tx = sesion.beginTransaction(); } private void manejaExcepcion(HibernateException he) throws HibernateException { sesion.getTransaction().rollback(); //tx.rollback(); throw new HibernateException("Ocurrió un error en la capa de acceso a datos", he); } }
Dígrafos(Grafos Dirigidos): son las clases que ayudan a construir los
grafos, se muestran diferentes clases como, arcos, grafos dirigidos, lista
de arcos, recorrido mínimo y recorrido de un grafo dirigido.
71
Clase De Diagrafo
import static java.awt.RenderingHints.KEY_ANTIALIASING; import static java.awt.RenderingHints.VALUE_ANTIALIAS_ON; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Point; import java.io.Serializable; import java.util.Vector; import javax.swing.JOptionPane; import Actors.Cruce; import Actors.Semaforos; import Utilitary.CirculoDibujable; import Utilitary.DibujaFiguras; /** * * @author ADMIN */ public class Digrafo implements Serializable, DibujaFiguras { /** * */ private static final long serialVersionUID = 1L; public Vector vertices; public Vector cruces; public Vector semaforos; public ListaArcos[] ListAdyaciencia; public boolean ponderado; //public static Color colorVert=new Color(250,100,55); public static Color colorArc=Color.RED; /** Creates a new instance of Digrafo */ public Digrafo() { this(50);//numero de verices por defecto } public Digrafo(int numMaxVertice)
72
{ vertices=new Vector(numMaxVertice); cruces=new Vector(numMaxVertice); semaforos=new Vector(); ListAdyaciencia=new ListaArcos[300];// arcos como maximo ponderado=false; } public boolean setVertice(CirculoDibujable vert) {// cada vez que ingresa un vertice aumenta los dos vectores ListAdyaciencia[vertices.size ()]=new ListaArcos(); return vertices.add (vert); } public boolean setCruce(Cruce cruce) { return cruces.add(cruce); } public int getNumVertice() { return vertices.size(); } public Cruce getCruce(int index ) { return (Cruce)cruces.get(index); } public CirculoDibujable getVertice(int index) { return (CirculoDibujable)vertices.get(index); } public boolean setCentroVertice(Point centro,int nVert) { CirculoDibujable vert=null; if(nVert< 0 && nVert >= vertices.size ()) { return false; } else
73
{ vert=(CirculoDibujable)vertices.get (nVert); vert.setCentro (centro); vertices.set (nVert,vert); } return true; } public CirculoDibujable[] getVertices() { return (CirculoDibujable[]) vertices.toArray (); } public Vector copiarVertices() { Vector retorno=new Vector(vertices.size ()); for(int i=0;i<vertices.size ();i++) {//constructor copia retorno.add (new CirculoDibujable((CirculoDibujable)vertices.get (i))); } return retorno; } public String VerticesACadena () { String cad="{ "; for(int i=0;i<vertices.size()-1;i++) { cad+="["+ vertices.get(i) + "], "; if((i+1)%5==0) cad+="\n "; } if(vertices.isEmpty()==false) { cad+="["+ vertices.get(vertices.size()-1)+"] "; } cad+="}"; return cad; } public int buscarPuntoEnVertices(Point punto) { int pos=-1,i=0; CirculoDibujable vert=null; while(i<vertices.size () && pos==-1)
74
{ vert=(CirculoDibujable)vertices.get (i); if(vert.puntoEstaEnRegion (punto)==true) { pos=i; } i++; } return pos; } public int buscarPuntoEnCruces(Point punto) { int pos = -1, i=0; CirculoDibujable cruce=null; while(i<cruces.size() && pos==-1) { cruce=(CirculoDibujable)cruces.get(i); if(cruce.puntoEstaEnRegion(punto)==true) { pos=i; } i++; } return pos; } public boolean eliminarCruce(int nCruce) { cruces.remove(nCruce); return true; } public boolean eliminarVertice(int nVert) { if(nVert< 0 && nVert >= vertices.size ()) { return false; } /* eliminar los vertices de todas las aristas */
75
for(int i=0;i<vertices.size();i++) { ListAdyaciencia[i].eliminarArcoConHijo (i,nVert);// eliminamos los vert de la lista } for(int i=nVert;i<vertices.size()-1;i++) { ListAdyaciencia[i]=ListAdyaciencia[i+1];// eliminamos la lista de hijos } ListAdyaciencia[vertices.size()-1]=null;// for(int i=0;i<vertices.size()-1;i++) { ListAdyaciencia[i].actualizarIndices(nVert);//reduce en una unidad cada //indice mayor al eliminado } /* eliminar el vertice*/ vertices.remove (nVert); // eliminar el vertice return true; } /** * Operaciones con Arcos * */ public void setArco(Arco ar) { int padre,hijo; padre=ar.getPadre (); // devuelve el indice hijo=ar.getHijo (); // devuelve el indice if(padre>=0 && padre <vertices.size () && hijo>=0 && hijo <vertices.size ()) { if(ListAdyaciencia[padre].buscarArco(padre,hijo)==null) {//si el arco no esta en la lista insertar al final ListAdyaciencia[padre].insertarFinal (ar); } } } public Arco getArco(int padre,int hijo) { int pos=ListAdyaciencia[padre].getIndexPadreHijo(padre,hijo); if(pos==-1)
76
return null; else return new Arco(ListAdyaciencia[padre].getDato(pos)); } public String arcosACadena() { String cad="{ "; for(int i=0;i<vertices.size();i++) { if(ListAdyaciencia[i].esVacia()==false) { cad+=ListAdyaciencia[i].toString(); cad+=" \n"; } } cad+=" }"; return cad; } public int[] buscarPuntoEnArcos(Point punto) { int[] datos=null; Arco ar=null; for(int i=0;i<vertices.size();i++) { if(ListAdyaciencia[i]!=null) { for(int j=0;j<ListAdyaciencia[i].getNumElem();j++) { ar=(Arco)ListAdyaciencia[i].getDato(j); if(puntoEstaArco(ar,punto)==true) { datos=new int[2]; datos[0]=i;datos[1]=j; //JOptionPane.showMessageDialog(null, "Datos[0] vale :"+datos[0]+"Datos[1] vale:"+datos[1]); break; } } } } return datos; }
77
private boolean puntoEstaArco(Arco ar, Point punto) { double m=0.0; boolean hecho=false; Point v1=null,v2=null; CirculoDibujable vert=null; vert=(CirculoDibujable)(vertices.get (ar.getPadre ())); v1=vert.getCentro (); vert=(CirculoDibujable)(vertices.get (ar.getHijo())); v2=vert.getCentro ();//obtengo los puntos int pos=-1,i=0; double b=0,y0=0,x0=0; boolean ladox=false,ladoy=false; if((v2.x-v1.x)==0) m=punto.y-v2.y; else m=(double)((v2.y-v1.y)/((v2.x-v1.x)*1.0));// calculo la pendiente b=(double)(v2.y-m*v2.x); if((punto.x>v1.x && punto.x<v2.x)||(punto.x>v2.x && punto.x<v1.x)) { y0=m*punto.x+b; if(Math.abs(y0-punto.y)<5) ladox=true; } if((punto.y>v1.y && punto.y<v2.y)||(punto.y>v2.y && punto.y<v1.y)) { x0=(punto.y-b)/(m*1.0); if(Math.abs(x0-punto.x)<5) ladoy=true; } if(ladox || ladoy) hecho=true; return hecho; } public void setPesoCodigo(int peso, String codigo, int[] datos) {// datos[0] padre y datos[1] hijo if(datos==null || datos.length!=2 ) return; ListAdyaciencia[datos[0]].setPesoCodigoArco(peso, codigo,datos[1]); ponderado=true; }
78
public int getPeso(int padre,int hijo) { return ListAdyaciencia[padre].getPesoArco(padre,hijo); } public void eliminarArco(int[] datos) { // datos[0] padre y datos[1] hijo, ambos en indices en listas if(datos==null || datos.length!=2 ) return; ListAdyaciencia[datos[0]].sacarDato(datos[1]); } public ListaArcos[] copiarArcos() { ListaArcos[] arcos=new ListaArcos[vertices.size()]; for(int i=0;i<vertices.size();i++) { arcos[i]=new ListaArcos(); if(ListAdyaciencia[i]!=null) { for(int j=0;j<ListAdyaciencia[i].getNumElem();j++) { arcos[i].insertarFinal(new Arco(ListAdyaciencia[i].getDato(j))); } } } return arcos; } public void dibujarFlecha(Arco ar,Graphics g) { double ang=0.0; double tx,ty; int radio=0,dist=8; Point punto1=null,punto2=null;// recuepro los datos de ambos vertices if(ar.getPadre()==-1 || ar.getHijo()==-1) return;// no existe arco; punto1=((CirculoDibujable)vertices.get(ar.getPadre())).getCentro(); punto2=((CirculoDibujable)vertices.get(ar.getHijo())).getCentro(); radio=((CirculoDibujable)vertices.get(ar.getHijo())).getRadio(); ty=-(punto1.y-punto2.y)*1.0;//la coordenadas de la ventana es al revez tx=(punto1.x-punto2.x)*1.0; ang=Math.atan (ty/tx); if(tx<0)
79
{// si tx es negativo aumentar 180 grados ang+=Math.PI; } Point p1=new Point(),p2=new Point(),punto=new Point(); // puntos para las flechas punto.x=(int)(punto2.x+radio*Math.cos (ang)); punto.y=(int)(punto2.y-radio*Math.sin (ang)); p1.x=(int)(punto.x+dist*Math.cos (ang-Math.toRadians (25))); p1.y=(int)(punto.y-dist*Math.sin (ang-Math.toRadians (25.0))); p2.x=(int)(punto.x+dist*Math.cos (ang+Math.toRadians (25.0))); p2.y=(int)(punto.y-dist*Math.sin (ang+Math.toRadians (25.0))); Graphics2D g2D=(Graphics2D)g; // g2D.setStroke (new BasicStroke(1.2f));// grosor de la linea g.setColor (colorArc); g.drawLine (punto1.x,punto1.y,punto.x,punto.y); g.drawLine (p1.x,p1.y,punto.x,punto.y); g.drawLine (p2.x,p2.y,punto.x,punto.y); // g2D.setStroke (new BasicStroke(1.0f));// grosor de la linea if(ponderado==true) { g2D.setPaint (new Color(0,0,0,250)); g2D.drawString (String.valueOf (ar.getPeso ()),(punto1.x+punto2.x)/2.0f,(punto1.y+punto2.y)/2.0f); } } public int getNumArcos() { int numArcos=0; for(int i=0;i<vertices.size();i++) {// recorro todos los padres if(ListAdyaciencia[i]!=null) { numArcos+=ListAdyaciencia[i].getNumElem(); } } return numArcos; } public void dibujarArcos(Graphics g) { if(ListAdyaciencia==null) return;
80
for(int i=0;i<vertices.size();i++) {// recorro todos los padres if(ListAdyaciencia[i]!=null) { for(int j=0;j<ListAdyaciencia[i].getNumElem();j++) {// recorro todos los hijos //JOptionPane.showMessageDialog(null, "El numero de elementos es: "+ListAdyaciencia[i].getNumElem()); dibujarFlecha(ListAdyaciencia[i].getDato(j),g); } } } } public void dibujar(Graphics g) { CirculoDibujable vert=null; CirculoDibujable cruce=null; CirculoDibujable sema=null; CirculoDibujable edificio=null; String cad=""; Graphics2D g2=(Graphics2D)g; //alisar curvas g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON); dibujarArcos(g); for(int i=0;i<vertices.size ();i++) { vert=(CirculoDibujable)(vertices.get(i)); cad=String.valueOf (i); vert.setNombre (cad); //vert.setColor(colorVert); vert.dibujar (g); // vert.rotular (g,i); } for(int i=0;i<cruces.size();i++) { cruce=(CirculoDibujable)(cruces.get(i)); cruce.setColor(Color.BLUE); cruce.dibujar(g); } for(int i=0;i<semaforos.size();i++) { sema=(CirculoDibujable)(semaforos.get(i));
81
sema.setColor(Color.BLUE); sema.dibujar(g); } } /** * Operacionescon digrafo **/ public String getProfundidad(Digrafo recProf) { Vector solEnIndices=new Vector(); recProf.vertices=this.copiarVertices (); recProf.ListAdyaciencia= RecorridoDigrafo.getRecorrido (this,RecorridoDigrafo.REC_PROFUNDIDAD,solEnIndices); recProf.ponderado=this.ponderado; String cad="Recorrido:"+solEnIndices.toString(); return cad; } public String getAnchura(Digrafo recAnch) { Vector solEnIndices=new Vector(); recAnch.vertices=this.copiarVertices (); recAnch.ListAdyaciencia= RecorridoDigrafo.getRecorrido (this,RecorridoDigrafo.REC_ANCHURA,solEnIndices); recAnch.ponderado=this.ponderado; String cad="Recorrido:"+solEnIndices.toString(); return cad; } public String getDijkstra(Digrafo dijkstra) { String cad=""; if(this.ponderado==false) { JOptionPane.showMessageDialog(null,"El Grafo no es ponderado","Error",0); return null; } cad=JOptionPane.showInputDialog(null,"Ingrese vertice Origen:"); int nOrigen=Integer.valueOf(cad);
82
if(nOrigen<0|| nOrigen>=vertices.size()) { JOptionPane.showMessageDialog(null,"Vertice no pertenece","Error",0); return null; } dijkstra.vertices=this.copiarVertices (); dijkstra.ListAdyaciencia=RecMinimo.getDijkstra(this,nOrigen); dijkstra.ponderado=this.ponderado; cad="Desde el vertice "+nOrigen+" hasta todos los demas"; return cad; } public String getCaminoCorto(Digrafo minimo) { String cad=""; int nOrigen=0,nDestino=0; if(this.ponderado==false) { JOptionPane.showMessageDialog(null,"El Grafo no es ponderado","Error",0); return null; } cad=JOptionPane.showInputDialog(null,"Ingrese vertice Origen:"); nOrigen=Integer.valueOf(cad); if(nOrigen<0|| nOrigen>=vertices.size()) { JOptionPane.showMessageDialog(null,"Vertice no pertenece","Error",0); return null; } cad=JOptionPane.showInputDialog(null,"Ingrese vertice Destino:"); nDestino=Integer.valueOf(cad); if(nDestino<0|| nDestino>=vertices.size()) { JOptionPane.showMessageDialog(null,"Vertice no pertenece","Error",0); return null; } minimo.vertices=this.copiarVertices (); minimo.ListAdyaciencia=RecMinimo.getCaminoCorto(this,nOrigen,nDestino); minimo.ponderado=this.ponderado; if(minimo.ListAdyaciencia==null) cad="No se encontro un camino";
83
else cad="ESTE es el camino mas corto desde "+nOrigen+" hasta "+nDestino+this.desplegarAdyacencia(minimo); return cad; } public String toString() { String cad=""; cad+="V="+this.VerticesACadena(); cad+="\nE="+this.arcosACadena(); return cad; } public void transladar(int tx, int ty) { } public String getFlujoMaximo(Digrafo digrafoAux) { return null; } public String desplegarAdyacencia( Digrafo grafo) { String cad=""; grafo.vertices=this.copiarVertices(); for(int i=0;i<grafo.vertices.size();i++) { for (int j=0;j<grafo.ListAdyaciencia[i].getNumElem();j++) { Arco arc=grafo.ListAdyaciencia[i].getDato(j); JOptionPane.showMessageDialog(null, ""+arc.getPadre()+" "+arc.getPeso()); } } return cad; } public Vector verticesRutaMasCorta(Digrafo grafo, int nOrigen, int nDestino){ if(this.ponderado==false) {
84
JOptionPane.showMessageDialog(null,"El Grafo no es ponderado","Error",0); return null; } else { grafo.vertices=this.copiarVertices (); grafo.ListAdyaciencia=RecMinimo.getCaminoCorto(this,nOrigen,nDestino); grafo.ponderado=this.ponderado; } String cad=""; Vector<Integer> verticesRuta=new Vector<Integer>(); //grafo.vertices=this.copiarVertices(); for(int i=0;i<grafo.vertices.size();i++) { for (int j=0;j<grafo.ListAdyaciencia[i].getNumElem();j++) { Arco arc=grafo.ListAdyaciencia[i].getDato(j); verticesRuta.add(arc.getPadre()); cad+=""+arc.getPadre()+"-"; } if(verticesRuta.isEmpty()){ return null; }else{ //verticesRuta.add((CirculoDibujable)vertices.get(nDestino)); //JOptionPane.showMessageDialog(null, "La ruta de vertices mas corta es = "+cad); } } return verticesRuta; } public int getNumCruces() { // TODO Auto-generated method stub return this.cruces.size(); } public boolean setSemaforo(CirculoDibujable sem) { if(sem==null){//JOptionPane.showMessageDialog(null,"es null en el metodo");
85
} return semaforos.add(sem); // TODO Auto-generated method stub } public Semaforos getSemaforo(int index) { // TODO Auto-generated method stub return (Semaforos)semaforos.get(index); } public int buscarPuntoEnSemaforos(Point point) { // TODO Auto-generated method stub int pos = -1, i=0; CirculoDibujable semaforo=null; while(i<semaforos.size() && pos==-1) { semaforo=(CirculoDibujable)semaforos.get(i); if(semaforo.puntoEstaEnRegion(point)==true) { pos=i; } i++; } return pos; } }
Diálogos: es el encargado de la captura de datos, en éste proceso se
implementaron ventanas de visualización para facilitar su ejecución, éste
maneja las clases de actualizar calle y actualizar cruces.
public class DialogUpdateCalle extends JDialog { private JPanel contentPanel = new JPanel(); public JTextField CruceOrigen; public JTextField CruceDestino; public JTextField CodigoCalle; public JTextField Nombre; public JTextField Capacidad;
86
public String cruceOrigen, cruceDestino,codigoCalle, calleNombre,calleObser; public int NodoInicio,NotoFin,CalleCapacidad, Longitud; public JButton cancelButton,okButton; public boolean puedesalir; public JTextField Observaciones; public JTextField NodoInicial; public JTextField NodoFinal; public JTextField LongitudCalle; /** * Launch the application. */ /*public static void main(String[] args) { try { DialogUpdateCalle dialog = new DialogUpdateCalle(); dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); dialog.setVisible(true); } catch (Exception e) { e.printStackTrace(); } }*/ /** * Create the dialog. */ public DialogUpdateCalle(JFrame parent, String title, boolean modal) { super(parent, title, modal); setBounds(100, 100, 450, 350); getContentPane().setLayout(new BorderLayout()); contentPanel.setBorder(new TitledBorder(new TitledBorder(new LineBorder(new Color(184, 207, 229)), "Informacin de Cruce", TitledBorder.LEFT, TitledBorder.TOP, null, new Color(0, 0, 255)), "Informacion de Cruce", TitledBorder.LEFT, TitledBorder.TOP, null, Color.BLACK)); getContentPane().add(contentPanel, BorderLayout.CENTER); contentPanel.setLayout(new GridLayout(1, 2, 0, 0)); { JPanel panel = new JPanel(); panel.setBorder(UIManager.getBorder("DesktopIcon.border")); contentPanel.add(panel); GridBagLayout gbl_panel = new GridBagLayout(); gbl_panel.columnWidths = new int[]{0, 0, 0, 0, 0, 0, 0};
87
gbl_panel.rowHeights = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; gbl_panel.columnWeights = new double[]{0.0, 0.0, 0.0, 0.0, 1.0, 1.0, Double.MIN_VALUE}; gbl_panel.rowWeights = new double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE}; panel.setLayout(gbl_panel); { JLabel LongCalle = new JLabel("Longitud :"); GridBagConstraints gbc_LongCalle = new GridBagConstraints(); gbc_LongCalle.anchor = GridBagConstraints.EAST; gbc_LongCalle.insets = new Insets(0, 0, 5, 5); gbc_LongCalle.gridx = 3; gbc_LongCalle.gridy = 2; panel.add(LongCalle, gbc_LongCalle); } { LongitudCalle = new JTextField(); GridBagConstraints gbc_LongitudCalle = new GridBagConstraints(); gbc_LongitudCalle.insets = new Insets(0, 0, 5, 5); gbc_LongitudCalle.fill = GridBagConstraints.HORIZONTAL; gbc_LongitudCalle.gridx = 4; gbc_LongitudCalle.gridy = 2; panel.add(LongitudCalle, gbc_LongitudCalle); LongitudCalle.setColumns(10); } { JLabel lblCodigoDeMapa = new JLabel("Cruce Origen :"); lblCodigoDeMapa.setHorizontalAlignment(SwingConstants.RIGHT); GridBagConstraints gbc_lblCodigoDeMapa = new GridBagConstraints(); gbc_lblCodigoDeMapa.insets = new Insets(0, 0, 5, 5); gbc_lblCodigoDeMapa.gridx = 3; gbc_lblCodigoDeMapa.gridy = 3; panel.add(lblCodigoDeMapa, gbc_lblCodigoDeMapa); } { CruceOrigen = new JTextField();
88
GridBagConstraints gbc_CruceOrigen = new GridBagConstraints(); gbc_CruceOrigen.insets = new Insets(0, 0, 5, 5); gbc_CruceOrigen.fill = GridBagConstraints.HORIZONTAL; gbc_CruceOrigen.gridx = 4; gbc_CruceOrigen.gridy = 3; panel.add(CruceOrigen, gbc_CruceOrigen); CruceOrigen.setColumns(10); } { JLabel lblCodigoCruce = new JLabel("Cruce Destino :"); GridBagConstraints gbc_lblCodigoCruce = new GridBagConstraints(); gbc_lblCodigoCruce.anchor = GridBagConstraints.EAST; gbc_lblCodigoCruce.insets = new Insets(0, 0, 5, 5); gbc_lblCodigoCruce.gridx = 3; gbc_lblCodigoCruce.gridy = 4; panel.add(lblCodigoCruce, gbc_lblCodigoCruce); } { CruceDestino = new JTextField(); GridBagConstraints gbc_CruceDestino = new GridBagConstraints(); gbc_CruceDestino.insets = new Insets(0, 0, 5, 5); gbc_CruceDestino.fill = GridBagConstraints.HORIZONTAL; gbc_CruceDestino.gridx = 4; gbc_CruceDestino.gridy = 4; panel.add(CruceDestino, gbc_CruceDestino); CruceDestino.setColumns(10); } { JLabel lblNombre = new JLabel("Codigo Calle :"); GridBagConstraints gbc_lblNombre = new GridBagConstraints(); gbc_lblNombre.anchor = GridBagConstraints.EAST; gbc_lblNombre.insets = new Insets(0, 0, 5, 5); gbc_lblNombre.gridx = 3; gbc_lblNombre.gridy = 5; panel.add(lblNombre, gbc_lblNombre); } {
89
CodigoCalle = new JTextField(); GridBagConstraints gbc_CodigoCalle = new GridBagConstraints(); gbc_CodigoCalle.insets = new Insets(0, 0, 5, 5); gbc_CodigoCalle.fill = GridBagConstraints.HORIZONTAL; gbc_CodigoCalle.gridx = 4; gbc_CodigoCalle.gridy = 5; panel.add(CodigoCalle, gbc_CodigoCalle); CodigoCalle.setColumns(10); } { JLabel lblCapacidadMaxima = new JLabel("Nombre :"); GridBagConstraints gbc_lblCapacidadMaxima = new GridBagConstraints(); gbc_lblCapacidadMaxima.anchor = GridBagConstraints.EAST; gbc_lblCapacidadMaxima.insets = new Insets(0, 0, 5, 5); gbc_lblCapacidadMaxima.gridx = 3; gbc_lblCapacidadMaxima.gridy = 6; panel.add(lblCapacidadMaxima, gbc_lblCapacidadMaxima); } { Nombre = new JTextField(); GridBagConstraints gbc_Nombre = new GridBagConstraints(); gbc_Nombre.anchor = GridBagConstraints.NORTH; gbc_Nombre.insets = new Insets(0, 0, 5, 5); gbc_Nombre.fill = GridBagConstraints.HORIZONTAL; gbc_Nombre.gridx = 4; gbc_Nombre.gridy = 6; panel.add(Nombre, gbc_Nombre); Nombre.setColumns(10); } { JLabel lblNoDeCarriles = new JLabel("Capacidad :"); GridBagConstraints gbc_lblNoDeCarriles = new GridBagConstraints(); gbc_lblNoDeCarriles.anchor = GridBagConstraints.EAST; gbc_lblNoDeCarriles.insets = new Insets(0, 0, 5, 5);
90
gbc_lblNoDeCarriles.gridx = 3; gbc_lblNoDeCarriles.gridy = 7; panel.add(lblNoDeCarriles, gbc_lblNoDeCarriles); } { Capacidad = new JTextField(); GridBagConstraints gbc_Capacidad = new GridBagConstraints(); gbc_Capacidad.insets = new Insets(0, 0, 5, 5); gbc_Capacidad.fill = GridBagConstraints.HORIZONTAL; gbc_Capacidad.gridx = 4; gbc_Capacidad.gridy = 7; panel.add(Capacidad, gbc_Capacidad); Capacidad.setColumns(10); } { JLabel lblObservaciones = new JLabel("Observaciones :"); GridBagConstraints gbc_lblObservaciones = new GridBagConstraints(); gbc_lblObservaciones.anchor = GridBagConstraints.EAST; gbc_lblObservaciones.insets = new Insets(0, 0, 5, 5); gbc_lblObservaciones.gridx = 3; gbc_lblObservaciones.gridy = 8; panel.add(lblObservaciones, gbc_lblObservaciones); } { Observaciones = new JTextField(); GridBagConstraints gbc_Observaciones = new GridBagConstraints(); gbc_Observaciones.insets = new Insets(0, 0, 5, 5); gbc_Observaciones.fill = GridBagConstraints.HORIZONTAL; gbc_Observaciones.gridx = 4; gbc_Observaciones.gridy = 8; panel.add(Observaciones, gbc_Observaciones); Observaciones.setColumns(10); } { JLabel lblNodoInicial = new JLabel("Nodo Inicial :"); GridBagConstraints gbc_lblNodoInicial = new GridBagConstraints();
91
gbc_lblNodoInicial.anchor = GridBagConstraints.EAST; gbc_lblNodoInicial.insets = new Insets(0, 0, 5, 5); gbc_lblNodoInicial.gridx = 3; gbc_lblNodoInicial.gridy = 9; panel.add(lblNodoInicial, gbc_lblNodoInicial); } { NodoInicial = new JTextField(); GridBagConstraints gbc_NodoInicial = new GridBagConstraints(); gbc_NodoInicial.insets = new Insets(0, 0, 5, 5); gbc_NodoInicial.fill = GridBagConstraints.HORIZONTAL; gbc_NodoInicial.gridx = 4; gbc_NodoInicial.gridy = 9; panel.add(NodoInicial, gbc_NodoInicial); NodoInicial.setColumns(10); } { JLabel lblNodoFinal = new JLabel("Nodo Final :"); GridBagConstraints gbc_lblNodoFinal = new GridBagConstraints(); gbc_lblNodoFinal.anchor = GridBagConstraints.EAST; gbc_lblNodoFinal.insets = new Insets(0, 0, 5, 5); gbc_lblNodoFinal.gridx = 3; gbc_lblNodoFinal.gridy = 10; panel.add(lblNodoFinal, gbc_lblNodoFinal); } { NodoFinal = new JTextField(); GridBagConstraints gbc_NodoFinal = new GridBagConstraints(); gbc_NodoFinal.insets = new Insets(0, 0, 5, 5); gbc_NodoFinal.fill = GridBagConstraints.HORIZONTAL; gbc_NodoFinal.gridx = 4; gbc_NodoFinal.gridy = 10; panel.add(NodoFinal, gbc_NodoFinal); NodoFinal.setColumns(10); } } { JPanel buttonPane = new JPanel();
92
buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT)); getContentPane().add(buttonPane, BorderLayout.SOUTH); { okButton = new JButton("OK"); //okButton.setAction(action); //okButton.setActionCommand("OK"); //okButton.addActionListener(this); buttonPane.add(okButton); //getRootPane().setDefaultButton(okButton); } { cancelButton = new JButton("Cancel"); //cancelButton.setActionCommand("Cancel"); //cancelButton.addActionListener(this); buttonPane.add(cancelButton); } } } public void limpiarCampos() { this.Nombre.setText(null); this.Capacidad.setText(null); this.CruceDestino.setText(null); this.CruceOrigen.setText(null); this.CodigoCalle.setText(null); } }
Guis: Estos manejan las clases aplicativo, escritorio, panel de dibujo,
programa, simulación, ventana inicio, ventana principal.
public class Programa { private JLabel splashLabel; private JProgressBar progreso; private JWindow splashScreen; private Timer tiempo; private int pos=0;
93
private VentPrincipal ventana; /** Creates a new instance of TeoriaGrafos */ public Programa() { crearSplashScreen(); splashScreen.setVisible(true);// arrancar con el splash hiloProgreso hilo=new hiloProgreso(); hilo.start(); ventana=new VentPrincipal();// correr el programa ventana.setVisible(true);// mostrar cuando el progreso acabe splashScreen.setVisible(false); splashScreen=null; hilo=null; } public void crearSplashScreen() { Dimension screenRect =Toolkit.getDefaultToolkit().getScreenSize(); splashLabel=new JLabel(new ImageIcon("images/splash2.JPG")); progreso=new JProgressBar(); progreso.setBorderPainted(true); progreso.setForeground(new Color(50,50,153,100)); progreso.setStringPainted(true);// estado numero splashScreen = new JWindow(); splashScreen.setLocation(screenRect.width/4+30, screenRect.height/4); splashScreen.setLayout(new BorderLayout()); splashScreen.add(splashLabel,BorderLayout.CENTER); splashScreen.add(progreso,BorderLayout.SOUTH); splashScreen.pack(); } public void pausa(int mlSeg) { try{// pausa para el splash Thread.sleep(mlSeg); }catch(Exception error){} }
94
public void progreso() { progreso.setValue(++pos); if(pos==101) { tiempo.stop(); } } class hiloProgreso extends Thread { public hiloProgreso() { super(); } public void run() { for(int i=1;i<=100;i++) { progreso.setValue(i); pausa(15); } } } public static void main(String[] args) { //JFrame.setDefaultLookAndFeelDecorated(false); final Logger logger = Logger.getLogger(Programa.class); BasicConfigurator.configure(); logger.info("Entering application."); Programa aplicativo=new Programa(); logger.info("Exiting application."); } }
Pojos: son las clases de persistencia que contienen los getter y los
setter, capaces de capturar la asignación de los atributos principales.
Permitiendo una comunicación con la base de datos. Las clases
manejadas son; Callelogica, callesemaforo,configuración vial entre otras.
95
Clase mapa import java.util.HashSet; import java.util.Set; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; /** * Mapa generated by hbm2java */ @Entity @Table(name = "mapa", catalog = "tesis10") public class Mapa implements java.io.Serializable { private String mapaCodigo; private String mapaName; private String mapaDescripcion; private Integer mapaLargo; private Integer mapaAncho; private Set crucelogicas = new HashSet(0); public Mapa() { } public Mapa(String mapaCodigo) { this.mapaCodigo = mapaCodigo; } public Mapa(String mapaCodigo, String mapaName, String mapaDescripcion, Integer mapaLargo, Integer mapaAncho, Set crucelogicas) { this.mapaCodigo = mapaCodigo; this.mapaName = mapaName; this.mapaDescripcion = mapaDescripcion; this.mapaLargo = mapaLargo; this.mapaAncho = mapaAncho; this.crucelogicas = crucelogicas; } @Id
96
@Column(name = "mapa_Codigo", unique = true, nullable = false, length = 20) public String getMapaCodigo() { return this.mapaCodigo; } public void setMapaCodigo(String mapaCodigo) { this.mapaCodigo = mapaCodigo; } @Column(name = "mapa_Name", length = 20) public String getMapaName() { return this.mapaName; } public void setMapaName(String mapaName) { this.mapaName = mapaName; } @Column(name = "mapa_Descripcion", length = 200) public String getMapaDescripcion() { return this.mapaDescripcion; } public void setMapaDescripcion(String mapaDescripcion) { this.mapaDescripcion = mapaDescripcion; } @Column(name = "mapa_Largo") public Integer getMapaLargo() { return this.mapaLargo; } public void setMapaLargo(Integer mapaLargo) { this.mapaLargo = mapaLargo; } @Column(name = "mapa_Ancho") public Integer getMapaAncho() { return this.mapaAncho; } public void setMapaAncho(Integer mapaAncho) { this.mapaAncho = mapaAncho; }
97
@OneToMany(fetch = FetchType.LAZY, mappedBy = "mapa") public Set getCrucelogicas() { return this.crucelogicas; } public void setCrucelogicas(Set crucelogicas) { this.crucelogicas = crucelogicas; } }
Utilidades: manejan las clases de circulo dibujante, cola, dibuja figuras, listas, entre otras.
Clase Cola public class Cola extends Lista implements Serializable { /** Creates a new instance of Cola */ public Cola () { super(); } public void acolar(Object dato) { super.insertarFinal (dato); } public Object desacolar() { return super.sacarPrimero (); } }
Mapping: contiene los archives de configuración, manejando hibernate,
hibernate revenge.
98
Hibernate reveng <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-reverse-engineering PUBLIC "-//Hibernate/Hibernate Reverse Engineering DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-reverse-engineering-3.0.dtd" > <hibernate-reverse-engineering> <table-filter match-catalog="tesis10" match-name="callelogica"/> <table-filter match-catalog="tesis10" match-name="callesemaforo"/> <table-filter match-catalog="tesis10" match-name="configuaracionvial"/> <table-filter match-catalog="tesis10" match-name="configuracionedificio"/> <table-filter match-catalog="tesis10" match-name="configuracionsemaforial"/> <table-filter match-catalog="tesis10" match-name="crucelogica"/> <table-filter match-catalog="tesis10" match-name="edificio"/> <table-filter match-catalog="tesis10" match-name="mapa"/> <table-filter match-catalog="tesis10" match-name="parametrocedificio"/> <table-filter match-catalog="tesis10" match-name="parametrocsemaforial"/> <table-filter match-catalog="tesis10" match-name="parametrocvial"/> <table-filter match-catalog="tesis10" match-name="semaforo"/> <table-filter match-catalog="tesis10" match-name="simulacion"/> <table-filter match-catalog="tesis10" match-name="tipvehiculo"/> <table-filter match-catalog="tesis10" match-name="vehiculocalle"/> <table name="CruceLogica" catalog="TESIS10"> <column name="cruce_Codigo"/> <column name="mapa_Codigo"/> <column name="cruce_Name"/> <column name="cruce_Capacidad"/> <column name="cruce_NumCarriles"/> <column name="cruce_Estado"/> </table> </hibernate-reverse-engineering>
Las siguientes clases, fueron tomadas como apoyo al desarrollo
aplicado. Tomadas del proyecto de simulacion1, desarrollado por el
docente y director de tesis “Christian Arias, Ingeniero De Sistemas del
LIDIS”.
import java.awt.Point;
99
public class PositionHelper { /** * Calcula la distancia que se debe recorrer en el eje Y para estar a la izquierda del punto sx,sy en * Relación a la línea que forma con dx,dy a una distancia distance * @param sx * @param sy * @param dx * @param dy * @param distance * @return */
public static int getSourceDistanceLeftYPoint (int sx, int sy, int dx, int dy, double distance) {
int x=dx-sx; System.out.println ("x:"+x); int y=dy-sy; System.out.println("y:"+y); double h=Math.sqrt(x*x+y*y); System.out.println ("h:"+h); int y2=(int) Math.round(distance*(x/h)); y2*=-1; return y2; } La fórmula de distancia entre dos puntos: Utilizamos una serie de datos para probar
x1 5
y1 7
x2 2
y2 3
distancias 3,162
d = √ (x1 – x2)² + (y1 – y2)² d = √ (5 – 2)² + (7 – 3)² d = 5 x= distancias*(5-2/d) x= (3,162*(3/5))
100
x= 2 t=y*(-1) t=2*(-1) t= -2
public static int getSourceLeftYPoint(int sx,int sy,int dx,int dy,double distance){ int y2=getSourceDistanceLeftYPoint(sx, sy, dx, dy, distance); return sy+y2; }
z=y2+t z=3+ (-2) z=1
Tenemos en este gráfico los datos de la tabla
Este es el triángulo que debe formar
101
public static int getSourceDistanceLeftXPoint(int sx,int sy,int dx,int dy,double distance){ int x=dx-sx; System.out.println("x:"+x); int y=dy-sy; System.out.println("y:"+y); double h=Math.sqrt(x*x+y*y); System.out.println("h:"+h); int x2=(int) Math.round(distance*(y/h)); System.out.println("x2:"+x2); return x2; } Le colocamos uno datos para probar
x1 5
y1 7
x2 2
y2 3
distancias 3,162
d = √ (x1 – x2)² + (y1 – y2)² d = √ (5 – 2)² + (7 – 3)² d = 5 y= distancias*(7-3/d) y= (3,162*(4/5)) y= 3
public static int getSourceLeftXPoint(int sx,int sy,int dx,int dy,double distance){ int x2=getSourceDistanceLeftXPoint(sx, sy, dx, dy, distance); return sx+x2; } z=2+ 3 z=5
Tenemos este gráfico los datos de la tabla
102
Este es el triángulo que debe formar
public static Point getSourceDistanceLeftPoint(Point source,Point target, double distance){ double x=target.getX()-source.getX(); double y=target.getY()-source.getY(); double h=Math.sqrt(x*x+y*y); int x2=(int) Math.round(distance*(y/h)); int y2=-1*((int) Math.round(distance*(x/h))); return new Point(x2,y2); } public static int getSourceDistanceRightYPoint(int sx,int sy,int dx,int dy,double distance){ return -1*getSourceDistanceLeftYPoint(sx, sy, dx, dy, distance); } z= getSourceLeftXPoint “ t ”*(-1)
103
z=t*(-1) z=-2*(-1) z=2
public static int getSourceDistanceRightXPoint(int sx,int sy,int dx,int dy,double distance){ return -1*getSourceDistanceLeftXPoint(sx, sy, dx, dy, distance); } z= getSourceLeftXPoint “ y ”*(-1) z=y*(-1) z=-3
public static Point getSourceDistanceRightPoint(Point source,Point target, double distance){ Point point=getSourceDistanceLeftPoint(source, target, distance); point.setLocation(point.getX()*-1, point.getY()*-1); return point; } public static Point getSourceLeftPoint(Point source,Point target, double distance){ Point point=new Point(); Point vector=getSourceDistanceLeftPoint(source, target, distance); point.setLocation(source.getX()+vector.getX(), source.getY()+vector.getY()); return point; } public static int getSourceRightYPoint(int sx,int sy,int dx,int dy,double distance){ int y2=getSourceDistanceRightYPoint(sx, sy, dx, dy, distance); // y2*=-1; return sy+y2; } C= getSourceDistanceRightYPoint “z” +y2 C= 2+3 C= 5
public static int getSourceRightXPoint(int sx,int sy,int dx,int dy,double distance){
104
int x2=getSourceDistanceRightXPoint(sx, sy, dx, dy, distance); return sx+x2; } S= getSourceDistanceRightXPoint “z” +x2 S= -3 +2 S= -1
public static Point getSourceRightPoint(Point source,Point target, double distance){ Point point=new Point(); Point vector=getSourceDistanceRightPoint(source, target, distance); point.setLocation(source.getX()+vector.getX(), source.getY()+vector.getY()); return point; } public static double getSquareHypo(int sx,int sy,int dx,int dy){ int x=dx-sx; System.out.println("x:"+x); int y=dy-sy; System.out.println("y:"+y); double h=Math.sqrt(x*x+y*y); return h; }
x1 5
y1 7
x2 2
y2 3
distancias 3,162
d = √ (x1 – x2)² + (y1 – y2)² d = √ (5 – 2)² + (7 – 3)² d = 5 Tenemos este gráfico los datos de la tabla
105
Este es el triángulo que debe formar
public static double getPendiente(int sx,int sy,int dx,int dy){ int x=dx-sx; System.out.println("x:"+x); int y=dy-sy; System.out.println("y:"+y); double p=(double)y/(double)x; return p; } p = (x1 – x2) / (y1 – y2) p = (5 – 2) / (7 – 3) p = 0,75
public static double getPendiente(Point source,Point target){ double x=target.getX()-source.getX(); double y=target.getY()-source.getY(); double p=y/x;
106
return p; } public static double getConstant(int px,int py,double pendiente){ double constant=py-pendiente*px; return constant; }
C= py-pendiente*px C= 6-4*3 C= -6
public static double getConstant(Point xy,double pendiente){ double constant=xy.getY()-pendiente*xy.getX(); return constant; } /** * Calcula la coordenada x del punto donde es cortada la línea formada * Por los puntos s (sx, sy) y d (dx, dy) por la línea perpendicular * Que pasa por el punto p (px, py) * @param sx * @param sy * @param dx * @param dy * @param px * @param py * @return */ public static double getX(int sx,int sy,int dx,int dy, int px,int py){ double p=getPendiente(sx, sy, dx, dy); double pp=-1/p; double b=getConstant(sx, sy, p); double bp=getConstant(px, py, pp); double nx=(bp-b)/(p-pp); return nx; } /** * Calcula la coordenada x del punto donde es cortada la línea formada * Por los puntos s (sx, sy) y d (dx, dy) por la línea perpendicular * Que pasa por el punto p (px, py) * @param sx * @param sy * @param dx * @param dy
107
* @param px * @param py * @return */ public static double getY(int sx,int sy,int dx,int dy, int px,int py){ double p=getPendiente(sx, sy, dx, dy); double pp=-1/p; double b=getConstant(sx, sy, p); double bp=getConstant(px, py, pp); double nx=(bp-b)/(p-pp); double ny=nx*p+b; return ny; } public static Point getClosestPoint(Point source,Point target, Point reference){ double p=getPendiente(source, target); double pp=-1/p; if(pp==0){ return new Point((int)source.getX(),(int)reference.getY()); } if(pp==Double.NEGATIVE_INFINITY){ return new Point((int)reference.getX(),(int)source.getY()); } if(pp==Double.POSITIVE_INFINITY){ return new Point((int)reference.getX(),(int)source.getY()); } double b=getConstant((int)source.getX(), (int)source.getY(), p); double bp=getConstant((int)reference.getX(),(int)reference.getY(), pp); double nx=(bp-b)/(p-pp); double ny=nx*p+b; Point point=new Point(); point.setLocation(nx, ny); return point; } public static double getY(int sx,int sy,int dx,int dy, int distance){ double p=getPendiente(sx, sy, dx, dy); double ang=Math.atan(p); double dely=Math.abs(distance*Math.sin(ang)); double ny; if(sy>dy){ ny=sy-dely;
108
}else{ ny=sy+dely; } return ny; } public static double getX(int sx,int sy,int dx,int dy, int distance){ double p=getPendiente(sx, sy, dx, dy); double b=getConstant(sx, sy, p); double ang=Math.atan(p); double dely=Math.abs(distance*Math.sin(ang)); double ny; if(sy>dy){ ny=sy-dely; }else{ ny=sy+dely; } double nx=(ny-b)/p; return nx; } /** * Retorna el punto sobre la recta partiendo de source dirigiéndose a target * y avanzando distance * @param sx * @param sy * @param dx * @param dy * @param distance * @return */ public static Point getNextPoint(Point source,Point target, int distance){ double p=getPendiente(source, target); if (p==Double.POSITIVE_INFINITY){ return new Point(source.x,source.y+distance); } if (p==Double.NEGATIVE_INFINITY){ return new Point(source.x,source.y-distance); } if (source.y==target.y){ if (source.x<target.x){ return new Point(source.x+distance,source.y); }else{
return new Point(source.x-distance,source.y); } }
109
double ang=Math.atan(p); double b=getConstant(source, p); double dely=Math.abs(distance*Math.sin(ang)); double ny; if(source.getY()>target.getY()){ ny=source.getY()-dely; }else{ ny=source.getY()+dely; } double nx=(ny-b)/p; Point ret=new Point(); ret.setLocation(nx, ny); return ret; } public static void main(String[] args) { /*System.out.println(getSourceLeftYPoint(5, 5, 11, 7, 3.162)); System.out.println(getSourceLeftYPoint(5, 5, 11, 3, 3.162)); System.out.println(getSourceLeftXPoint(20, 20, 24, 17, 10)); System.out.println(getSourceLeftYPoint(20, 20, 24, 17, 10)); System.out.println(getSourceLeftXPoint(20, 20, 16, 17, 10)); System.out.println(getSourceLeftYPoint(20, 20, 16, 17, 10)); System.out.println(getSourceLeftXPoint(20, 20, 24, 23, 10)); System.out.println(getSourceLeftYPoint(20, 20, 24, 23, 10)); System.out.println(getSourceLeftXPoint(20, 20, 16, 23, 10)); System.out.println(getSourceLeftYPoint(20, 20, 16, 23, 10)); */ double x=getX(12, 9, 4, 17, 5,10); double y=getY(12, 9, 4, 17, 5,10); System.out.println(x); System.out.println(y); double xx=getX(40, 20, 32, 26, 5); double yy=getY(40, 20, 32, 26, 5); System.out.println(xx); System.out.println(yy); }
}
110
24 RESULTADOS DE LA SIMULACIÓN
De acuerdo al diseño implementado en la aplicación se puede observar una
barra de herramientas con diferentes características, que ayuda el fácil
manejo entre en usuario y el sistema. La barra de herramientas, permite
crear parámetros como: calles, semáforos, grafos dirigidos, generación de
rutas. Ver(ilustración 7).
Ilustración 7 "Barra de Herramientas"
Ya implementados los componentes de la barra de herramientas se puede
observar un escenario completo,
111
Ilustración 8 "Escenario Completo Aplicativo"
Mediante el proceso de capturar información, se recolecta información
referente a los objetos estudiados, como por ejemplo: información de Calle,
Semáforos, Cruces, entre otros. Ver (Ilustración 9).
Ilustración 9 "Ejemplo de Captura de Datos"
112
A continuación se muestra en ejecución la simulación final con todos los
parámetros asignados
Ilustración 10 "Escenario Final Simulado"
113
25 TRABAJO DE CAMPO
Este trabajo simula algunas características del tráfico vehicular partiendo
desde una base de datos de entrada, en el que se realiza una serie de
observaciones de diferentes calles de la ciudad que presentan
complejidad por la cantidad de vehículos que circulan diariamente.
Estudiamos diferentes escenarios con una serie de problemas comunes
como, la autopista sur oriental con carrera 66, calle36 con carrera 46
cruce popularmente llamado “puerto rellena” y calle 5 con Guadalupe. Se
pudo observar que en muchos de estos cruces se presentan diferentes
sentidos de vías, señalización y cambio de los semáforos.
CRUCE AUTOPISTA SIMÓN BOLÍVAR ENTRE CALLES 36 CON CRA 46
Foto tomada de Google Maps.
Ilustración 11 "Cruce Calle 36 con Cra 46"
En los cruces de la autopista Simón Bolívar ubicada entre la Calle 36
con Cra 46 se presenta una relación de nodos, donde se despliegan
determinados cruces. En cada uno de los ellos se observan riesgos de
accidentalidad, por el ancho de la vía y por el largo de la calle, cuando
114
un semáforo cambia su estado a verde hay ocasiones en que los
semáforos restantes aun no cambian a rojo, no se tiene un control
exacto por el ancho de la calle. Provocando dificultades de movilidad.
A continuación se observa una gráfica donde entra a jugar un papel muy
importante la semaforización en esta importante vía de la ciudad, donde
se muestra cada una de las opciones de cambio de los semáforos. Ver
(Ilustración 8).
Ilustración 12 "Estados de Semaforización Calle 36 con 46”
115
CRUCE CALLE 5 CON CARRERA 56
Ilustración 13 "Calle 5 con Guadalupe"
SEMÁFOROS ESTUDIADOS CALLE 5 CON GUADALUPE Semáforo 1 (verde) S4 verde, S3 rojo, S2 verde, Semaforo1a (verde opción 2) S1a verde, todos los demás en rojo Semáforo 2 (verde) S1 verde, S1a rojo, S3 rojo, S4 verde Semáforo 2ª (verde) S1 verde, S3 rojo, S4 rojo Semáforo 3 (verde) todos los demás en rojo Semáforo 4 S1 verde, S2 verde, S3 rojo
116
Observaciones
Configuración semaforial: de acuerdo al trabajo de campo realizado en la
calle 5 con Guadalupe algunos de los semáforos repiten estado de
acuerdo a unos tiempos. Lo cual no se ve estipulado en el modelo
(tiempos en estados repetidos)
Al realizar el análisis en la base de datos nos damos cuenta que en el
ejemplo tomado (calle 5 con Guadalupe) se presenta una pequeña
incongruencia con el modelo, teniendo en cuenta que no asociamos el
objeto cruce con el objeto semáforo, por tal motivo en este punto de la
ciudad se presenta un cruce complicado entre los carriles del sistema
masivo y los vehículos particulares, ocasionado por los tiempos de
estado en la semaforización allí ubicada.
En el modelo ya estructurado, nos encontramos con otro inconveniente,
al introducir datos en el modelo, nos dimos cuenta que muchos de los
objetos relacionados tienen la misma llave foránea, por tal motivo no
dejaba continuar con el proceso, lo cual tocaba saltar el paso, ya que
existía o estaba siendo usado ese atributo.
En el análisis realizado con el ejemplo tomado (calle 5 con Guadalupe)
según nuestro concepto se relacionaron los siguientes objetos: Mapa,
Semáforo, Cruce, Calle, CalleSemáforo.
Se tiene como objetivo del trabajo de campo, recolectar información básica
y algunas características que influyen en el tráfico vehicular, teniendo en
cuenta una serie de factores y puntos importantes como las que veremos a
continuación:
117
• Tamaño de la calle.
• Número de autos que entran.
• Número de autos que salen.
• Tamaño promedio de la cola.
• Espaciamiento promedio entre vehículos.
• Tiempo y cambio de semáforo en verde y rojo.
• Tiempo de reacción de los automóviles.
AUTOPISTA SUR ORIENTAL CON CALLE 66 Calzada principal de la autopista sur oriental, este sector es conocido por ser
una zona muy comercial y al mismo tiempo transitado de manera intensiva,
esto ocasiona gran congestión vehicular provocada en muchas ocasiones por
el corto tiempo de cambios de estado en la semaforización.
Este sitio crítico de la ciudad presenta un problema común que se vive a diario
en algunas calles, y es el ancho del cruce principal, ocasionando accidentes
por el paso de vehículos lentos al pasar el semáforo.
Ilustración 14 "Calle 10 con Carrera 66"
118
AUTOPISTA SUR ORIENTAL CON CALLE66 “ESTADOS DE SEMAFOROS”
Ilustración 15 "Estados De Semaforización Calle 10 con 66"
TIEMPOS
• De Rojo a Verde
• A) 1’ 59 seg
• B) 1’ 35 seg
• C) 2’ 44 seg
• D) 1’ 19 seg
• De Verde a Rojo
• A) 24 seg
• B) 42 seg
• C) 27 seg
• D) 1’ 28 seg
119
Según el estudio realizado a los estados de semaforización, en éste sector de
la ciudad se puede observar que los tiempos no son continuos, teniendo en
cuenta que son manipulados en diferentes horas críticas por parte del
organismo de transito. Aunque este proceso es intervenido por el factor
humano, se puede apreciar que los tiempos en estado verde, son demasiado
cortos para el flujo de entrada vehicular que allí se presenta, ocasionando con
esto embotellamiento y largas colas, provocando tráfico en la vía.
Ilustración 16 "Carrera 66 con Calle 9"
120
Ilustración 17 "Estados De Semaforización Carrera 66 con Calle 9"
TIEMPOS
• De Rojo a Verde • A) 46 seg • B) 1’ 18 seg
• De Verde a Rojo • A) 1’ 11 seg • B) 35 seg
Ilustración 18 "Foto Carrera 66 con Calle 10"
121
26 RECOLECCIÓN DE INFORMACIÓN
Esta trabajo se realizó con el objetivo de que la simulación a realizar
esté basada en datos reales, se recolectó información básica en cada
una de las calles, realizando varias pruebas donde cada uno de los
ítems formo parte importante de la información. Como por ejemplo:
El largo y ancho de la calle
Número de cruces
Cambio de semáforo
Número de vehículos en circulación en hora pico
Nivel de accidentalidad
Por medio de un reloj cronometrado, se tomó cada uno de los tiempos
de cada semáforo, y se determinó problemas frecuentes como lo son los
cambios repentinos de los semáforos, ocasionando con esto, mayor
dificultad en el tráfico, se observó mala señalización en algunas de las
vías, y en ocasiones irrespeto y violación al código de transito por medio
de los conductores, se tomo una fotografía, que verifica la información
recolectada.
27 FLUJO DE ENTRADA
Esta información juega un papel muy importante ya que se desea
conocer la cantidad de vehículos que ingresan a una vía, los resultados
obtenidos se usarán para alimentar nuestro sistema, obteniendo
resultados reales. En primera medida se define por medio de un periodo
de conteo (1 minuto) el número de vehículos que entran, haciendo ésta
122
operación de forma manual, almacenando los datos en una tabla para
llevar un mejor control y análisis de la simulación.
De acuerdo a varias pruebas realizadas, vistas en el trabajo de campo,
se puede constatar que la variación de autos que ingresan es muy alta,
debido a esto se decidió tomar como tiempo de partida el tiempo que
tarda el semáforo de cambiar de rojo a verde o de verde a rojo
incluyendo el tiempo de semáforo en amarillo ya que muchos
conductores toman este tiempo como verde.
Durante el día se presentan varios cambios en los tiempos de semáforo,
como lo son en las horas pico, por tal motivo se decidió tomar un
promedio de estos tiempos. De igual forma se hacen las pruebas y el
análisis para el flujo de salida.
28 TRABAJOS FUTUROS
La implementación de la simulación en su primera versión maneja lo que
es el motor de la aplicación, donde se muestran las diferentes formulas
matemáticas que nos permite realizar el movimiento de los vehículos,
velocidades, tiempo de respuesta, aceleración, etc. Esta información es
fundamental para futuros trabajos, porque de aquí parte toda la lógica de
movimiento de la simulación.
De acuerdo a esta información en futuros trabajos se puede
implementar a:
123
1) Mapas o diagramas de sitios estratégicos de la ciudad para ayudar a
solucionar los problemas comunes, obteniendo información de
manera visual detallada.
2) Medir la tasa de accidentalidad causadas por problemas como:
Daño en los semáforos
Deterioro en el sistema vial.
Falta de civismo en los conductores
Mala señalización
3) Control de tiempo de semaforización en horas pico para disminuir el
tráfico vehicular.
4) Llevar a cabo la implementación de cada una de las
recomendaciones como solución, desde el organismo de transito y
transportes de la ciudad.
5) Llevar un control de reportes estadísticos, con base en los datos
analizados y arrojados por el sistema. En el aplicativo se manejo una
herramienta para facilitar el proceso de reportes. Ver (Ilustración 18).
Ilustración 19 "Reporte generado por JasperReports"
124
29 TECNOLOGÍAS APLICADAS DEL PROYECTO
JEE15 (Java Enterprise Edition): “..es una plataforma de
programación, parte de la Plataforma Java para desarrollar y
ejecutar software de aplicaciones en Lenguaje de programación
Java con arquitectura de N capas distribuidas y que se apoya
ampliamente en componentes de software modulares
ejecutándose sobre un servidor de aplicaciones.
La plataforma Java EE está definida por una especificación.
Similar a otras especificaciones del Java Community Process,
Java EE es también considerada informalmente como un
estándar debido a que los proveedores deben cumplir ciertos
requisitos de conformidad para declarar que sus productos son
conformes a Java EE; estandarizado por The Java Community
Process / JCP..”
EJB16 (Enterprise JavaBeans): “..Un "Java Bean" es un
componente utilizado en Java que permite agrupar
funcionalidades para formar parte de una aplicación, esto puede
ser: un "Java Bean" agrupando información personal, datos
sobre un pedimento, requerimientos de ordenes, etc.
Un "Enterprise Java Bean" también agrupa funcionalidades para
una aplicación, sin embargo, a diferencia de un "Java Bean" un
"Enterprise Java Bean" es un "deployable component", el
término "deployable component" implica que existe un ambiente
de ejecución, éste ambiente es precisamente un "EJB
15
http://es.wikipedia.org/wiki/Java_EE 16
http://www.osmosislatina.com/java/ejb.htm
125
(Enterprise Java Bean) Container" parte de un java application
server.
Un "Java Bean" requiere ser integrado con otros componentes
para que éste sea funcional, mientras un "Enterprise Java Bean"
a través de un "EJB Container" puede ser activado
("deployed")..”
JPA17 (Java Persistence API): “..Más conocida por sus siglas
JPA, es la API de persistencia desarrollada para la plataforma
Java EE e La Java Persistence API, a veces referida como JPA,
es un framework del lenguaje de programación Java que maneja
datos relacionales en aplicaciones usando la Plataforma Java en
sus ediciones Standard (Java SE) y Enterprise (Java EE).
La JPA fue originada a partir del trabajo del JSR 220 Expert
Group. Ha sido incluida en el estándar EJB3..”
HIBERNATE18: “..Es una herramienta de Mapeo objeto-relacional
(ORM) para la plataforma Java (y disponible también para .Net
con el nombre de NHibernate) que facilita el mapeo de atributos
entre una base de datos relacional tradicional y el modelo de
objetos de una aplicación, mediante archivos declarativos (XML) o
anotaciones en los beans de las entidades que permiten
establecer estas relaciones..”
ICE-Faces19: “..Creado y administrado por ICEsoft Technologies
Inc., ICEfaces es una herramienta líder de código abierto de Ajax,
17
http://es.wikipedia.org/wiki/Java_Persistence_API 18
http://www.clickmatica.com/?page_id=348 19
http://tuforo.org/icefaces-y-icemobile-ee-listos-para-websphere-app-server-websphere-portal-y-
rational/
126
ICEfaces es más que un componente de la librería JSF Ajax, es
un framework J2EE Ajax para desarrollar y el desplegar
aplicaciones empresariales ricas (AER). Con ICEfaces, los
desarrolladores empresariales Java pueden desarrollar fácilmente
aplicaciones empresariales ricas en Java, no JavaScript..”
ORACLE20: “..Oracle es un sistema de gestión de base de
datos relacional (o RDBMS por el acrónimo en inglés de
Relational Data Base Management System), desarrollado
por Oracle Corporation.
Se considera a Oracle como uno de los sistemas de bases de
datos más completos, destacando:
o Soporte de transacciones,
o Estabilidad,
o Escalabilidad
o Soporte multiplataforma.
o Escogimos la versión gratuita de este gestor de base de
datos debido a su buen desempeño manejando y
almacenando datos, además de la gran experiencia de la
empresa creadora de este.
Su dominio en el mercado de servidores empresariales ha sido
casi total hasta hace poco, recientemente sufre la competencia
del Microsoft SQL Server de Microsoft y de la oferta de otros
RDBMS con licencia libre como PostgreSQL, MySql o Firebird.
Las últimas versiones de Oracle han sido certificadas para poder
trabajar bajo GNU/Linux..”
20
http://www.orasite.com/administracion-de-oracle/conceptos-basicos-oracle-10g-introduccion
127
MySQL21: “..El sistema de base de datos operacional MySQL es
hoy en día uno de los más importantes en lo que hace al diseño y
programación de base de datos de tipo relacional. Cuenta con
millones de aplicaciones y aparece en el mundo informático como
una de las más utilizadas por usuarios del medio. El programa
MySQL se usa como servidor a través del cual pueden conectarse
múltiples usuarios y utilizarlo al mismo tiempo..”
21
http://www.definicionabc.com/tecnologia/mysql.php
128
GLOSARIO DE TÉRMINOS
Término Descripción
Tráfico
Vehículo
Modelo
Macroscópico.
Modelo
Microscópico
Simulador
Es el fenómeno causado por el flujo de vehículos
en una vía, calle o autopista.
Medio de transporte que permite el traslado de un
lugar a otro. Cuando traslada a personas u
objetos es llamado vehículo de transporte.
“Se enfocan en captar las relaciones globales del
flujo de tráfico, tales como velocidad de los
vehículos, flujo vehicular y densidad de tráfico”.
(hace referencia al pie de página 10)
“Se enfocan en la descripción del
comportamiento del flujo del tráfico vehicular a
través de describir las entidades discretas
individuales y atómicas que interactúan unas con
otras”. (hace referencia al pie de página 10)
“Un simulador es un aparato, por lo general
informático, que permite la reproducción de un
sistema”. (hace referencia al pie de página 3)
129
Semáforo22
Calle o Ruta
Intersección
Usuario
Administrador del
sistema
“Un semáforo es una estructura diseñada para
sincronizar dos o más threads o procesos, de
modo que su ejecución se realice de forma
ordenada y sin conflictos entre ellos.”.
Espacio por lo general lineal que facilita la
movilidad de vehículos o personas.
Espacio vial donde se cruzan dos o más
caminos.
Persona encargada de manipular los tiempos y
recursos de la herramienta simulada
Es la persona encargada de iniciar el sistema,
regularmente estas personas tienen su login y
password de acceso.
22
http://www.rastersoft.com/OS2/CURSO/SEMAFORO.HTM
130
CONCLUSIONES
1. Modelar el tráfico en la ciudad viéndolo desde una simulación
microscópica es un desafío para las personas que investigan y estudian
el tema, teniendo en cuenta que es un modelo muy complejo y que
puede representar con veracidad y exactitud el tráfico actual, pero esto
implica un costo computacional muy alto si se proyecta en una
simulación. Por tal motivo, con un conjunto de reglas básicas se puede
conseguir una buena aproximación, con la cual es viable concretar un
simulador, logrando simular sistemas medianamente complejos para
suministrar valiosa información y solucionar problemas ya existentes.
2. Todo el procedimiento aplicado en este desarrollo está basado en
información y resultados verídicos analizados previamente como
estrategia de trabajo para llevar un concepto de movilidad vehicular que
se vive a diario en las calles de la ciudad.
3. No existía información detallada a cerca de la usabilidad del aplicativo,
todo se genero mediante un proceso de investigación, basándonos en
las necesidades del usuario.
4. Teniendo en cuenta lo complejo que es el modelo de simulación se
desarrolló una interfaz gráfica, con el fin de hacer más fácil y amigable al
usuario el funcionamiento del sistema.
131
BIBLIOGRAFIA
ROGER P. ROESS, (2004). “TRAFFIC ENGINEERING”.
ADALFE, Rodolfo; Los semáforos y el control dinámico del tránsito. Editorial: Representaciones y servicios de Ingeniería,1976.
CAL, Rafael; CÁRDENAS, James. Ingeniería de tránsito, fundamentos y aplicaciones. México: Universidad del Valle, 2003. 527p.
CLANDER R., HERMAN E. y MONTROLL E. Traffic Dynamics: Studies in car Following. En: Operational Research. S.l. no.2 (1958) ; p.41-43.
ERLANDSSON, Lennart; BAUNER, David. Clean Air Workshop 2003. [On line] Rio de Janeiro: Clean air net, 2005.
(MATEMÁTICAS DISCRETAS, “Carlos Garcia” , Editorial Prentice
Hall)