Entrades classificades amb: camins

Primers passos en el rutatge al QGIS

En aquest post mostraré els passos que he hagut de seguir per tal de crear el primer dels mòduls que utilitza funcions de rutatge en el QGIS. En aquest cas, volem traslladar el mòdul que calcula els 3 camins a les escoles bressol i llars d’infants més pròximes a cada portal de la ciutat de Mataró. En primer lloc presento les capes amb les quals es treballa. Llavors segueixo amb la creació del mòdul i la seva utilització.

Capes de treball

Actualment amb el GeoMedia treballem amb bases de dades de Microsoft Access majoritàriament. Aquestes incorporen tot tipus de dades, ja sigui taules amb informació sobre el padró o el cadastre, que no estan georeferenciades, o capes de punts, línies o polígons com poden ser els mapes de carrers, illes, cruïlles i serveis públics de la ciutat. Les dades en aquest format ens permeten una gran versatilitat d’ús i facilitat tan en l’ús com en la creació, modificació i eliminació. També són fàcilment exportables a qualsevol altre tipus de format per seguir treballant. Ocasionalment també treballem amb arxius SHAPE.

El QGIS permet gestionar formats raster i vectorials a través de les biblioteques GDAL i OGR, així com altres bases de dades. Una biblioteca GDAL i OGR és un conjunt de programes que estan formats per comandes, cada un amb moltes possibilitats d’ús.

Les capes més comunes amb les quals hem treballat són el Vector Layer, on utilitzem arxius SHAPE (.shp), i Delimited Text Layer on utilitzem arxius CSV (.csv).

Ambdos tipus de dades poden ser modificats fàcilment: tan crear, inserir, modificar o eliminar objectes i/o camps, la qual cosa els fa idonis treballar amb aquests tipus d’arxius ja que si volem fer proves per poder desenvolupar les consultes o els mòduls, ens són de gran utilitat.

Procés de creació

Per crear la interfície gràfica s’utilitza un creador de models que porta incorporats una sèrie de funcionalitats. Haurem d’anar a la caixa d’eines de processat i allà “crear model nou”.
fuc
I seguidament se’ns obra la següent finestra:
nou
Les dues imatges següents corresponen a la columna de l’esquerra de l’anterior imatge hi tenim tots els tipus de paràmetres amb els quals podem treballar, i si canviem a la pestanya de algoritmes, trobem totes les funcions amb les quals podrem treballar sobre les dades. Cal veure el funcionament d’aquestes per tal de poder-les utilitzar correctament.

fuc

dades

 

 

 

 

 

Seguidament, vam afegir el tipus de dades i buscar les funcionalitats adequades per construir la interfície gràfica.

dades2
Una vegada introduïdes les capes, va ser necessari buscar una funcionalitat que convertís el tipus de geometria dels objectes de les capes de punts ja que van sorgir problemes per què obteníem una capa buida. En el nostre cas vam utilitzar el mòdul “Convert Geometry type”.
convert
Seguidament vam començar la recerca d’entre les funcionalitats alguna que calculi una ruta entre dos punts. No existeix una funcionalitat que faci tal funció, així que vam seguir la cerca. Vam seguir buscant entre els plugins que permet instal·lar el QGIS. Vam trobar-ne un que si que fa aquesta funció però no ens era d’utilitat ja que no hi ha cap manera d’automatitzar el procés de càlcul de les distàncies. Això doncs, vam recórrer a l’últim recurs: crear un script en Python que realitzi la funció.

Vam trobar un script que calculava la ruta entre dos punts sobre un graf de carrers. Aquest script utilitza una funció interna de la API de QGIS anomenada “dijkstra” que et retorna un camí. El següent script és el que vam trobar a Internet:

##ruta=name
##ruta=name
##points=vector
##network=vector
##output=output vector

#Algorithm body
#==================================
from PyQt4.QtCore import *
from PyQt4.QtGui import *

from qgis.core import *
from qgis.gui import *
from qgis.networkanalysis import *
from processing.tools.vector import VectorWriter

point_layer = processing.getObject(points)
network_layer = processing.getObject(network)
writer = VectorWriter(output, None, [QgsField("order", QVariant.Int)],
network_layer.dataProvider().geometryType(), network_layer.crs())

# prepare graph
vl = network_layer
director = QgsLineVectorLayerDirector(vl,-1,'','','',3)
properter = QgsDistanceArcProperter()
director.addProperter( properter )
crs = vl.crs()
builder = QgsGraphBuilder( crs )

# prepare points
features = processing.features(point_layer)
point_count = point_layer.featureCount()
points = []
for f in features:
  points.append(f.geometry().asPoint())
tiedPoints = director.makeGraph( builder, points )
graph = builder.graph()
route_vertices = []

for i in range(0,point_count-1):
    progress.setPercentage(int(100 * i/ point_count))
    
    from_point = tiedPoints[i]
    to_point = tiedPoints[i+1]
    from_id = graph.findVertex(from_point)
    to_id = graph.findVertex(to_point)

    (tree,cost) = QgsGraphAnalyzer.dijkstra(graph,from_id,0)
    if tree[to_id] == -1:
        continue # ignore this point pair
    else:
        #collect all the vertices between the points
        route_points = []
        curPos = to_id 
        while (curPos != from_id):
            route_points.append(graph.vertex(
graph.arc(tree[curPos]).inVertex()).point())
           curPos = graph.arc( tree[ curPos ] ).outVertex()
        route_points.append(from_point)
    # add a feature
    fet = QgsFeature()
    fet.setGeometry(QgsGeometry.fromPolyline(route_points))
    fet.setAttributes([i])
    writer.addFeature(fet)
del writer

Un cop testejat i debuguejat, vam començar amb la modificació de l’script per tal d’obtenir el resultat desitjat. Aquest va ser un procés complex ja que s’havia de canviar el programa per dins. Després de forces entrebancs en el procés vam aconseguir un resultat força aproximat al que volíem. Van caldre forces hores per acabar de depurar el codi ja que teníem petits errors que costaven de detectar.

##dintreilla=vector
##EscolesBressol=vector
##network=vector
##output=output vector
#Algorithm body
#==================================
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import time
from qgis.core import *
from qgis.gui import *
from qgis.networkanalysis import *
from processing.tools.vector import VectorWriter

start_time = time.time()
network_layer = processing.getObject(network)

inputPoint = processing.getObject(dintreilla)
features = processing.features(inputPoint)

inputPoint2 = processing.getObject(EscolesBressol)
features2 = processing.features(inputPoint2)

di= 0
eb= 0
id = -1
fields = []
fields.append (QgsField("ID", QVariant.Int))
fields.append (QgsField("Length", QVariant.Int))
fields.append(QgsField("From_Node",QVariant.String))
fields.append(QgsField("To_Node",QVariant.String))

writer = VectorWriter(output, None, 
fields, network_layer.dataProvider().geometryType(), network_layer.crs())

#Per buscar els 3 millors de cada punt

for fea1 in features:
    di=di+1
    #xx = fea1.geometry().asPoint().x()
    #yy = fea1.geometry().asPoint().y()
    #pStart = QgsPoint(xx, yy)
    from_node = fea1.attributes()
    inici = from_node[0]
    print inici
    fea2=None
    features2 = processing.features(inputPoint2)
    eb = -1
    vec = []
    for fea2 in features2:
        eb=eb+1
        id  = id + 1
        nom = fea2.attributes()
        desti = nom[2]
       #---------------------------------------------------------------
        vl = network_layer
        director = QgsLineVectorLayerDirector(vl,-1,'Cost','Cost_inver','',3)
        properter = QgsDistanceArcProperter()
        director.addProperter(properter)
        crs = vl.crs()
        builder = QgsGraphBuilder(crs ,True,0.001)

        # prepare points
        points = []
        points.append(fea1.geometry().asPoint())
        points.append(fea2.geometry().asPoint())

        tiedPoints = director.makeGraph( builder, points )
        graph = builder.graph()

        route_vertices = []
        for i in range(0,2-1):
            from_point = tiedPoints[i]
            to_point = tiedPoints[i+1]

            from_id = graph.findVertex(from_point)
            to_id = graph.findVertex(to_point)

            (tree,cost) = QgsGraphAnalyzer.dijkstra(graph,from_id,0)
            if tree[to_id] == -1:
                continue # ignore this point pair
            else:
                # collect all the vertices between the points
                route_points = []
                curPos = to_id 
                while (curPos != from_id):
                    route_points.append(graph.vertex(
graph.arc(tree[curPos]).inVertex()).point())
                    curPos = graph.arc(tree[curPos]).outVertex()

                route_points.append(from_point)

            # add a feature
            geom=QgsGeometry.fromPolyline(route_points)
            fet = QgsFeature()
            fet.setGeometry(QgsGeometry.fromPolyline(route_points))
            fet.setAttributes([id, geom.length(), inici, desti])
            vec.append(fet)
           
    if (len(vec) > 0):
        vec.sort(key=lambda vec: vec[1])
        for i in range (0,3):
            writer.addFeature(vec[i])
del writer
print("--- %s seconds ---" % (time.time() - start_time))

Finalment vam aconseguir un resultat que s’ajustava a les nostres necessitats, i així completar el procés de creació d’un mòdul amb el QGIS. Vam posar l’script en un mòdul per a python, vam posar-li totes les connexions necessàries.
python
I aquest en va ser el resultat final de tot el procés:
final

Procés d’utilització

Aquí es descriu el procés d’utilització del mòdul per trobar els 3 Camins més pròxims a una Escola Bressol i una d’infants. Aquest comença amb la preparació de les dades a la llegenda o panell de capes del QGIS. En el cas que ens ocupa necessitarem 4 capes SHAPE, 3 de punts i una de segments. Les 3 capes de punts són les Escoles Bressol, les Llars d’Infants  i els dintreilles, que són tots els portals de la ciutat.  I la capa de segments són el conjunts de carrers de la ciutat, és a dir, per on hem de trobar el camí.

Primer de tot, hem de tenir les capes en el tipus desitjat: SHAPE. En el cas que no estiguin ja en aquest format, cal transformar-les per tal de poder-hi treballar. Un cop les tinguem, les guardem per tal de poder-les agafar i emprar.

Tal com s’indica a la fotografia, s’afegeix cada capa via Capa -> Añadir capa -> Añadir capa vectorial:
afe3

afe

Seleccionem explorar i amb l’ajuda de la finestra, busquem els arxius SHAPE que volem posar.

afe2

Repetim l’acció 3 vegades més fins a aconseguir les 4 capes desitjades, tal i com es veu a la foto.

Un cop fet, anem al panell de la dreta de la pantalla on hi ha la “caja de herramientas de procesado” i busquem a l’apartat de Modelos -> CCU, un model anomenat “3EB més pròximes”.
afe4

Una vegada trobat, cal executar-lo. S’obrirà una pestanya amb el següent diàleg:

afe5

Posem a cada pestanya la capa que ens demani: a la primera hi posem la xarxa de carrers sobre la qual volem treballar, a la segona hi posem els Dintreilles o portals de la ciutat(assegurar-se de que sigui la versió “dintreilla_trajectes”) i finalment les escoles bressol o les llars d’infants. Haurem de repetir el procés per cada una de les capes: una per les EB i una altre per les LI.

Un cop tot estigui a punt, només cal executar el procés i esperar a obtenir el resultat. El temps d’espera pot variar segons l’ordinador on s’estigui executant aquest.

Quan finalitzi el procés cal guardar el resultat en un fitxer SHAPE, ja que està en un fitxer temporal i per tant, es perdria en el moment en què tanquem el programa.

Prova del mòdul

En aquest apartat es mostra un exemple de mostra del mòdul. No utilitzaré la capa del ‘dintreilla’ ja que es massa gran i per veure el funcionament, amb una simple capa en tenim prou.

En aquest cas utilitzaré una capa amb un punt (de color vermell) que serà el punt d’origen i una altre capa (de color verd) amb els possibles destins més propers. D’aquesta manera es pot veure ben clar el funcionament.
ex1

Posem en marxa el mòdul i el resultat que obtenim és el següent:

ex2

A la imatge es pot veure el graf de carrers de la ciutat de Mataró. S’hi pot veure 3 camins ressaltats de color verd clar. Tots tres tenen com a origen el punt vermell.

Sobre la Generació de Taules de Proximitat

 

 

En anteriors entrades ja hem parlat del Graf de Trams de Carrer (GTC). El GTC és un conjunt de segments connectats per nodes per on poden circular els vianants de la ciutat per fer els seus trajectes a peu dins de la vila (vegeu l’entrada: ‘Sobre el Graf de Trams de Carrer (GTC) ‘).

També es va veure com mitjançant unes característiques pròpies dels segments del graf podem saber la distància mínima entre un punt qualsevol, normalment una adreça qual­sevol, i un centre proveïdor de servei (CAP, Escola, Centre Cívic etc.), això ens va por­tar al un nou concepte de Zona d’Influència basat en la distància sobre el GTC o en el temps necessari per recórrer aquesta distància (vegeu l’entrada: ‘Nou concepte de Zo­nes d’Influència lligat als desplaçaments de la població’).

El GTC és un graf orientat i d’aquí ve que en els seus segments podem tenir informació del Cost (temps que triga una persona en recórrer el segment anant a una determinada velocitat quan va en el sentit del tram) i Cost_invers (temps que triga quan va en sentit contrari), això també es pot aplicar a una población segmentada segons l’edat, ja que presumiblement la velocitat será diferent per una persona de 25 anys que per una per­sona de 65.

Una de les possibilitats que té el GTC dins del Geomèdia (GM) és la utilització d’eines de rutatge, com el Geomèdia Transportation Mànager (GMTM) que ens permeten, a més a més de generar el propi graf, calcular els camins més curts o òptims segons una determinada funció cost entre dues o més entitats o Classes d’Entitat (taula o conjunt d’entitats del mateix tipus). Una de les característiques del GMTM que es va desenvo­lupar és la possibilitat de generar cobertures a partir d’unes classes d’entitat inicials que ens van facilitar la construcció de l’eina per generar les Zones d’Influència basades en el GTC que ja s’ha descrit.

L’explotació de totes les possibilitats de trobar camins entre entitats a través d’un graf, si no es vol efectuar el càlcul directament en el moment, o si no es disposa dels ele­ments de càlcul ‘on line’, ens porta a la generació de taules amb tots els camins entre les entitats origen i les entitats final, que anomenem ‘Taules de Proximitat’.  Després per obtenir determinats trajectes només haurem de consultar la taula corresponent, sense necessitat de disposar de les eines de rutatge i ni tan sols l’entorn del GM.

Per la creació d’aquestes taules es va construïr un mòdul del GM anomenat ‘Generació de Taules de Proximitat’ que anem a descriure tot seguit [Aquest mòdul formava part del Projecte Final de Carrera de Eric Belando que va presentar el 2011 a la EUPMt per obtenir el Títol d’Enginyer Tècnic Industrial] . El format del Generador de Taules és el d’un formulari on haurem de plasmar les entrades i les opcions d’aquest càlcul, vegeu la figura 1.

Fig 1. Interfície d’usuari per la Generació de Taules de Proximitat

Anem a repassar les tres seccions que es poden veure en aquest formulari

ENTRADES

  • Entitats  ‘origen’ ,des de les quals volem accedir a les entitats proveïdores d’un servei, aquestes poden ser entitats puntuals, com ara els números de policia o portals a peu de carrer, que podem resumir en una adreça determinada tipus Nom de Carrer i Numèro de Carrer. Un altre tipus d’entitats genèriques de la ciutat poden ser les Illes de cases, o també les Parcel·les, en aquest cas serien entitats tipus àrea. Com que per fer el rutatge necessitem una entitat puntual d’origen, en el cas de les entitats tipus àrea s’agafaria el centroide. De totes maneres l’aplicatiu pot funcionar amb qualsevol tipus d’entitat origen, parades de bus, contenidors d’escombreries etc.
  • Entitats ‘destí’, cap a on es dirigeixen els camins que surten de les entitats ori­gen, aquestes entitats serien les que proveeixen d’un servei: Centres d’Assistència Primària, Escoles etc.
  • Graf de Trams de Carrer que utilitzarem. S’han de donar dues classes d’entitat: segments i nusos. El graf ha de tenir informació dels valors de les variables Cost i Cost_invers de cada segment i si es volen calcular taules amb segmentació d’edats hem de tenir aquests mateixos valors de Cost i Cost_invers per a cada segment d’edat. Per això hi ha l’opció d’escollir el GTC que en interessi.

PARÀMETRES

  • S’ha d’indicar si volem generar la taula agafant com a criteri de proximitat la dis­tància (camins de les entitats ‘origen’ fins a les entitats ‘final’ que siguin més curts en distància) o bé el temps  (camins de les entitats ‘origen’ fins a les enti­tats ‘final’ que siguin més curts en temps).

Si hem agafat com a criteri el temps haurem d’escollir si volem segmen­tació per edats o no (si és així el GTC l’ha d’incloure).

  • Nombre d’entitats a les que volem generar camins per ordre de proximitat. Ca­mins a 4 les Escoles Bressol (EB), per exemple, més properes. En aquest cas de cada entitat ‘origen’ hi haurà 4 camins a les 4 EB més properes.
  • Paràmetres interns de la generació de taules. Com ara quina ha la distància mà­xima de les entitats ‘origen’ al GTC per possibilitar el rutatge. O els les agrupa­cions d’entitats que podem fer com a bloc de càlcul.

SORTIDES

  • A quina connexió del GM volem posar les taules que generem com a sortida.
  • Els noms que tenen cada una de les dues taules que generem. Una taula de trajec­tes, o camins, per tant amb geometria de línia. I una taula sense geometria on només posem les dades de la proximitat les entitats ‘final’ per a cada entitat ‘origen’, aquesta proximitat pot ser expressada en metres (distància) o en minuts (temps) segons el mètode que hàgim utilitzat

Aquesta  interfície de la figura 1 correspon a la generació de taules de trajectes i proxi­mitat des de les Illes de Cases de la ciutat de Mataró fins a totes les Llars d’Infants (es­coles bressol privades) de la ciutat. Considerant la unitat de mesura el temps empleat en fer el recorregut , per les les persones de menys de 25 anys. Es considera també que cerquem els trajectes i la proximitat a les dues Llars d’Infants més properes a cada Illa de Cases.

A la part esquerra del formulari tenim les ENTRADES on s’ha d’escollir la classe d’entitat de les entitats ‘origen’ i la classe d’entitat de les entitats ‘destí’ i on també s’ha d’escollir l’atribut identificador de cada entitat. Igualment s’ha de seleccionar les dues classes d’entitat del GTC, els segments i els nodes.

A la part central hi ha els PARÀMETRES de les taules que ja hem comentat.

A la dreta hi ha la configuració de les SORTIDES, connexió escollida d’entre les con­nexions actives del GM, i els noms de les dues taules de sortida que estem generant. També hi ha una retroacció del procés que s’està desenvolupant, una barra de progrés abaix de tot i un ‘log’ de quan s’ha acabat de processar cada una dels blocs d’entitats en que s’ha dividit del procés. En el cas de la figura 1, s’ha escollit blocs de 100 entitats i com que hi ha unes 800 i escaig Illes tindrem unes nou línies en la finestra, indicant per a cada bloc en quin moment s’ha completat. Aquest informació ens pot permetre decidir quin format de bloc és més eficient per a cada procés i cada màquina.

 

Fig 2. Generació de la Taula des de cada portal

A la figura 2 veiem el cas de la generació de les taules de trajectes i proximitat des de cada portal, n’hi ha uns 20000, si s’agafen blocs de 100 es necessiten 200 blocs tal com mostra la finestra de seguiment del procés.

També a la figura 3 es mostra la taula generada,  amb el primer camp D_S_I (districte_secció_illa) que correspon de cada Illa de Cases, el segon camp que es veu correspon a l’entitat d’arribada, que està definida pel nom de la Llar d’Infants corresponent, el camp número 4 correspon al temps definit en minuts que es trigaria en anar des de l’Illa del primer camp a la Llar d’Infants del segon camp, la resta de camps indiquen la geometria o sigui el dibuix del trajecte i només els pot interpretar el GM. Com es pot veure per a cada Illa hi ha dos trajectes, són els dos més ‘curts’ a les Llars d’Infants més ‘properes’.

Fig. 3. Taula de les sortides dels trajectes: TrajectesILLES_LI_25a_2

Aquesta  mateixa informació està indicada en un sol registre, en comptes de dos, en la taula de proximitat, on no hi ha cap ‘geometria’. Vegeu la figura 4 on la primera entitat de destí que es troba és la més propera (en temps)

Fig 4. Taula de les sortides de la proximitat: ProximitatILLES_LI_25a_2

En resum aquest mòdul és molt interessant per tenir una base de dades de trajectes o de proximitat en temps o distància, que es poden utilitzar en la publicació ràpida d’informacions que es puguin cercar a partir de ubicacions sobre el mapa de la ciutat o de llistats de domicilis, o d’adreces amb georeferenciació.   Pot ser molt útil per un recurs web, com ara el el servei WFS, del que es pugui obtenir un o varis camins a partir d’una petició d’una pàgina web on hi hagi una ubicació sobre el mapa de mataró. Només cal que, per que la informació sigui actual, les taules es va­gin generant periòdicament, cosa que s’aconsegueix de forma senzilla utilitzant aquest aplicatiu mostrat.