Referencias Lineales

Un Sistema de Referencia Lineal (SRL) es un sistema donde elementos (puntos o segmentos) son localizados por una medida a lo largo de un elemento lineal. El SRL puede ser usado para referenciar eventos para cualquier red de elementos lineales, por ejemplo carreteras, tuberías, y líneas eléctricas. Un evento es definido en el SRL por un identificador (ID) de ruta y una medida. Una ruta es un camino en la red, generalmente compuesto desde varios elementos lineales en el mapa de entrada. Los eventos pueden ser puntos o líneas (segmentos).

Un SRL es creado desde elementos lineales y puntos de un mapa vectorial. Los puntos (hitos) deben tener asociados atributos especificando una línea y una distancia. Las distancias desde el inicio de los elementos lineales en el mundo real son especificadas mediante el hito+desplazamiento. Generalmente, los hitos se dan en kilómetros y el desplazamiento en metros.

Se cuenta con los comandos v.lrs.create para crear un sistema de referencia lineal, v.lrs.label para crear etiquetas en el LRS, v.lrs.segment para crear puntos/segmentos en el LRS, y v.lrs.where para encontrar el identificador de ruta y el desplazamiento para puntos/líneas dadas en un mapa vectorial usando un sistema de referencia lineal.

Creación del SRL

El comando v.lrs.create genera un SRL desde datos lineales y puntuales. Este comando une todas las líneas conectadas con el mismo ID en una sola polilínea. Por eso es recomendable trabajar con polilíneas en lugar de líneas segmentadas. Para convertir un grupo de líneas en polilíneas se puede usar el comando v.build.polylines.

El mapa vectorial de hitos (puntos) debe contener campos llamados start_mp, start_off, end_mp y end_off, todos de doble precisión. Para el ordenamiento de los hitos basta con ingresar números en forma incremental en el campo start_mp indicando el orden a lo largo de la línea (ruta).

En el comando v.lrs.create, los parámetros lidcol y pidcol especifican los campos que contendrán los IDs de las rutas que relacionan los hitos (puntos) y las rutas (líneas) entre sí.

Ejemplo

Considere el siguiente archivo, llamado red.txt, en donde se define una red de carreteras consiste de tres rutas:

VERTI:
L  7 1
 12  14
 18  23 
 34  25 
 42  44
 63  51
 69  76
 90  92
 1   1
L  4 1
 42  44
 35  67
 56  89
 48  97
 1   2
L  5 1
 34  25
 68  22
 80  38
 81  60
 95  67
 1   3

Los comandos necesarios para importar esta información en Grass y asociarle una tabla de datos, sería:

$ v.in.ascii in=red.txt out=red_temp format=standard --overwrite

$ v.db.addtable red_temp

Luego es necesario convertir estas líneas a polilíneas pues, como se indicó anteriormente, Grass así lo prefiere. Se debe tener cuidado en mantener el mismo identificador de categoría (que utilizan las líneas originales) en las polilíneas resultantes, pues éste será el identificador de ruta:

$ v.build.polylines red_temp out=red cats=first --overwrite

El siguiente archivo representa el mapa de hitos, llamado hitos.txt. Nótese que el campo "ruta" se utiliza para asociar cada hito con su respectiva ruta y que la distancia que existe entre cada hito es de 1 Km:

cat,x,y,ruta,start_mp
1,12,14,1,1
2,18,23,1,2
3,34,25,1,3
4,42,44,1,4
5,63,51,1,5
6,69,76,1,6
7,90,92,1,7
8,42,44,2,1
9,35,67,2,2
10,56,89,2,3
11,48,97,2,4
12,34,25,3,1
13,68,22,3,2
14,80,38,3,3
15,81,60,3,4
16,95,67,3,5

Para importar el archivo de datos anterior en Grass y agregar los campos que se necesitarán posteriomente, es necesario ejecutar la siguiente serie de comandos:

$ v.in.ascii cat=1 x=2 y=3 fs="," skip=1 columns="cat int,x int,y int,ruta int, start_mp double" in=hitos.txt out=hitos --overwrite

$ v.db.addcolumn hitos col="start_off double"

$ v.db.addcolumn hitos col="end_mp double"

$ v.db.addcolumn hitos col="end_off double"

Finalmente se puede crear el SRL utilizando el siguiente comando:

$ v.lrs.create in_lines=red points=hitos out=rutas err=errores lidcol=cat pidcol=ruta rstable=rutas threshold=1 --overwrite

En este paso el software genera un error al escribir la tabla de rutas. Sin embargo, la tabla resultante puede ser reparada mediante el siguiente comando:

$ v.build map=rutas

Ahora la tabla de rutas creada puede ser desplegada mediante el comando:

$ db.select table=rutas

Localización de eventos

El comando v.lrs.segment crea puntos/segmentos desde líneas de entrada, un SRL y posiciones. El formato del archivo de entrada es el siguiente:

P <id_punto> <id_ruta> <hito>+<desplaz> [<corrimiento>]
L <id_segmento> <id_ruta> <hito>+<desplaz> <hito>+<desplaz> [<corrimiento>]

El corrimiento es la distancia ortogonal desde la ruta. Corrimientos positivos posicionan los elementos a la derecha de la ruta, y corrimiento negativos posicionan los elementos a la izquierda de la ruta.

Ejemplo

Para localizar varias ubicaciones puntuales a lo largo de las rutas, se utilizará el siguiente archivo llamado eventosP.txt :

P 1 1 1+200 4
P 2 1 3+500 -4
P 3 2 5+0 0
P 4 2 2+100 2
P 5 3 2+300 -2
P 6 3 3+500 0

El comando que permite crear la nueva capa de puntos a partir de la red de rutas, sería:

$ v.lrs.segment file=eventosP.txt input=rutas output=eventosP rstable=rutas --overwrite

También, se puede utilizar un archivo con eventos lineales como el que se presenta a continuación, llamado eventosL.txt :

L 1 1 1+100 3+400 4
L 2 2 1+0 2+500 -4
L 3 3 2+200 4+400 25

Para crear la capa de líneas a partir de la red de rutas, el comando es prácticamente el mismo del caso anterior:

$ v.lrs.segment file=eventosL.txt input=rutas output=eventosL rstable=rutas --overwrite

Referencia inversa

El comando v.lrs.where encuentra el identificador de ruta junto con el hito y desplazamiento, para puntos dados en un mapa vectorial usando un SRL. Este comando cuenta con una opción (thresh) para definir la distancia máxima a la línea más cercana. Cualquier elemento que se encuentre a una distancia mayor, de cualquiera de la rutas, no será procesado.

Ejemplo

Se utilizará el siguiente archivo, llamado coords.txt, que contiene las coordenadas de varios puntos para los que se desea averiguar su posición en la ruta:

cat,x,y
1,12,14
2,42,44
3,63,51
4,42,44
5,35,67
6,34,25
7,68,22

El comando utilizado para importar en Grass la información de estos puntos sería:

$ v.in.ascii in=coords.txt out=coords columns="cat int,x int,y int" cat=1 x=2 y=3 fs=',' skip=1 --overwrite

La referencia inversa producirá varias líneas de texto con la información de los eventos en la ruta, por lo que se puede usar el direccionamiento (>) para escribir estos datos a un archivo:

$ v.lrs.where points=coords lines=rutas rstable=rutas thresh=1 > rutasP.txt

El conjunto de datos de salida (rutasP.txt), se muestra a continuación:

1|1|1.000000+0.000000
2|1|4.000000+0.000000
3|1|5.000000+0.000000
4|1|4.000000+0.000000
5|2|2.000000+0.000000
6|1|3.000000+0.000000
7|3|2.000000+0.000000

Ejercicio