pgr_trsp - Camino más corto con giros restringidos (TRSP)

pgr_trsp — Devuelve el camino más corto con soporte para restricciones de giros

Disponibilidad

  • Versión 2.1.0

    • Nuevo Via prototypes

      • pgr_trspViaVertices

      • pgr_trspViaEdges

  • Versión 2.0.0

    • Función oficial

Soporte

Descripción

La ruta más corta restringida por giro (TRSP) es un algoritmo de ruta más corta que opcionalmente puede tener en cuenta restricciones de giro complicadas como las que se encuentran en las redes de carreteras del mundo real. En cuanto al rendimiento, es casi tan rápido como la búsqueda A* pero tiene muchas características adicionales, como funcionar con bordes en lugar de los nodos de la red. Devuelve un conjunto de filas (seq, id1, id2, cost) o (seq, id1, id2, id3, cost) que forman una ruta.

pgr_trsp(sql text, source integer, target integer,
                  directed boolean, has_rcost boolean [,restrict_sql text]);
RETURNS SETOF (seq, id1, id2, cost)
pgr_trsp(sql text, source_edge integer, source_pos float8,
                      target_edge integer, target_pos float8,
                  directed boolean, has_rcost boolean [,restrict_sql text]);
RETURNS SETOF (seq, id1, id2, cost)
pgr_trspViaVertices(sql text, vids integer[],
                  directed boolean, has_rcost boolean
                  [, turn_restrict_sql text]);
RETURNS SETOF (seq, id1, id2, id3, cost)
pgr_trspViaEdges(sql text, eids integer[], pcts float8[],
                  directed boolean, has_rcost boolean
                  [, turn_restrict_sql text]);
RETURNS SETOF (seq, id1, id2, id3, cost)

Las características principales son:

El algoritmo de la ruta más corta restringida por giro (TRSP) es similar a la estrella fugaz en que puede especificar restricciones de giro.

La configuración de TRSP es en su mayoría la misma que Dijkstra shortest path con la adición de una tabla de restricción de giro opcional. Esto proporciona una manera fácil de agregar restricciones de giro a una red de carreteras colocándolas en una tabla separada.

sql

una consulta SQL que debe proporcionar un conjunto de registros con los siguientes campos:

SELECT id, source, target, cost, [,reverse_cost] FROM edge_table
id

int4 Identificador del borde

source

int4 Identificador del vértice inicial del borde

target

int4 Identificador del vértice final del borde

Costo

float8 Costo del recorrido sobre el borde. Un costo negativo evitará que el borde sea insertado en el gráfico.

reverse_cost

(opcional) El costo para el recorrido inverso del borde. Esto sólo se utiliza cuando los parámetros directed y has_rcost son True (ver el comentario anterior sobre los costos negativos).

source

int4 identificador del nodo de partida

target

int4 identificador del nodo de llegada

dirigido

true Si la gráfica es direccionada

has_rcost

Si es True, el campo reverse_cost del conjunto de registros generados se utilizan para el calcular el costo de la travesía del borde en la dirección opuesta.

restrict_sql

(opcional) una consulta SQL, que debe proporcionar un conjunto de registros con los siguientes campos:

SELECT to_cost, target_id, via_path FROM restrictions
to_cost

float8 restricción del costo de giro

target_id

int4 identificador del borde donde se aplica la restricción

via_path

Lista de aristas text separadas por comas en el orden inverso de rule

Otra variante de TRSP que permite especificar el Identificador del borde de partida y de llegada junto con una fracción para interpolar la posición:

source_edge

int4 identificador del borde de partida

source_pos

float8 fracción de 1 que define la posición del sobre el borde de partida.

target_edge

int4 Identificador del borde de llegada

target_pos

float8 fracción de 1 que define la posición del sobre el borde de llegada.

Devuelve el conjunto de:

seq

Secuencia de registros

id1

Identificador del nodo visitado

id2

Identificador del borde (-1 para el ultimo registro)

Costo

costo para atravesar desde el nodo id1 usando el borde``id2`` hasta su otro extremo

Soporte para Vias

Advertencia

Las funciones de Soporte para Vias son prototipos. No se están considerando todos los casos de esquina.

También tenemos soporte para vias donde puedes generar una ruta de A a B a C, etc. Admitimos ambos métodos por encima de solo pasar un arreglo de vértices y/o un arreglo de aristas y la posición porcentual a lo largo de la arista en dos arreglos.

sql

una consulta SQL que debe proporcionar un conjunto de registros con los siguientes campos:

SELECT id, source, target, cost, [,reverse_cost] FROM edge_table
id

int4 Identificador del borde

source

int4 Identificador del vértice inicial del borde

target

int4 Identificador del vértice final del borde

Costo

float8 Costo del recorrido sobre el borde. Un costo negativo evitará que el borde sea insertado en el gráfico.

reverse_cost

(opcional) El costo para el recorrido inverso del borde. Esto sólo se utiliza cuando los parámetros directed y has_rcost son True (ver el comentario anterior sobre los costos negativos).

vids

int4[] Un arreglo ordenado de NODE id la ruta irá de principio a fin.

dirigido

true Si la gráfica es direccionada

has_rcost

Si es True, el campo reverse_cost del conjunto de registros generados se utilizan para el calcular el costo de la travesía del borde en la dirección opuesta.

restrict_sql

(opcional) una consulta SQL, que debe proporcionar un conjunto de registros con los siguientes campos:

SELECT to_cost, target_id, via_path FROM restrictions
to_cost

float8 restricción del costo de giro

target_id

int4 identificador del borde donde se aplica la restricción

via_path

Lista de aristas `` text`` separadas por comas en el orden inverso de rule

Otra variante de TRSP permite especificar EDGE id junto con una fracción para interpolar la posición:

eids

int4 Un arreglo ordenado de EDGE id que la ruta tiene que atravesar

Pct

`` float8`` Un arreglo de posiciones fraccionarias a lo largo de las respectivas aristasen eids, donde 0.0 es el comienzo de la arista y 1.0 es el final.

Devuelve el conjunto de:

seq

Secuencia de registros

id1

Identificador de la ruta

id2

Identificador del nodo visitado

id3

Identificador del borde (-1 para el ultimo registro)

Costo

costo para atravesar desde el nodo id2 usando el borde id3 hasta su otro extremo

Ejemplos Adicionales

Ejemplo

Sin restricción de giros

SELECT * FROM pgr_trsp(
        'SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table',
        7, 12, false, false
    );
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   7 |   6 |    1
   1 |   8 |   7 |    1
   2 |   5 |   8 |    1
   3 |   6 |   9 |    1
   4 |   9 |  15 |    1
   5 |  12 |  -1 |    0
(6 rows)

Ejemplo

Con restricción de giros

Entonces una consulta con restricciones de giro es creada de la siguiente forma:

SELECT * FROM pgr_trsp(
        'SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table',
        2, 7, false, false,
        'SELECT to_cost, target_id::int4,
        from_edge || coalesce('','' || via_path, '''') AS via_path
        FROM restrictions'
    );
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   2 |   4 |    1
   1 |   5 |  10 |    1
   2 |  10 |  12 |    1
   3 |  11 |  11 |    1
   4 |   6 |   8 |    1
   5 |   5 |   7 |    1
   6 |   8 |   6 |    1
   7 |   7 |  -1 |    0
(8 rows)

SELECT * FROM pgr_trsp(
        'SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table',
        7, 11, false, false,
        'SELECT to_cost, target_id::int4,
        from_edge || coalesce('','' || via_path, '''') AS via_path
        FROM restrictions'
    );
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   7 |   6 |    1
   1 |   8 |   7 |    1
   2 |   5 |   8 |    1
   3 |   6 |   9 |    1
   4 |   9 |  15 |    1
   5 |  12 |  13 |    1
   6 |  11 |  -1 |    0
(7 rows)

Una consulta de ejemplo mediante identificadores de vértices y puntos de vía:

SELECT * FROM pgr_trspViaVertices(
        'SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table',
        ARRAY[2,7,11]::INTEGER[],
        false,  false,
        'SELECT to_cost, target_id::int4, from_edge ||
        coalesce('',''||via_path,'''') AS via_path FROM restrictions');
 seq | id1 | id2 | id3 | cost
-----+-----+-----+-----+------
   1 |   1 |   2 |   4 |    1
   2 |   1 |   5 |  10 |    1
   3 |   1 |  10 |  12 |    1
   4 |   1 |  11 |  11 |    1
   5 |   1 |   6 |   8 |    1
   6 |   1 |   5 |   7 |    1
   7 |   1 |   8 |   6 |    1
   8 |   2 |   7 |   6 |    1
   9 |   2 |   8 |   7 |    1
  10 |   2 |   5 |   8 |    1
  11 |   2 |   6 |   9 |    1
  12 |   2 |   9 |  15 |    1
  13 |   2 |  12 |  13 |    1
  14 |   2 |  11 |  -1 |    0
(14 rows)

Una consulta de ejemplo mediante identificadores de borde y vias:

SELECT * FROM pgr_trspViaEdges(
        'SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost,
        reverse_cost FROM edge_table',
        ARRAY[2,7,11]::INTEGER[],
        ARRAY[0.5, 0.5, 0.5]::FLOAT[],
        true,
        true,
        'SELECT to_cost, target_id::int4, FROM_edge ||
        coalesce('',''||via_path,'''') AS via_path FROM restrictions');
 seq | id1 | id2 | id3 | cost
-----+-----+-----+-----+------
   1 |   1 |  -1 |   2 |  0.5
   2 |   1 |   2 |   4 |    1
   3 |   1 |   5 |   8 |    1
   4 |   1 |   6 |   9 |    1
   5 |   1 |   9 |  16 |    1
   6 |   1 |   4 |   3 |    1
   7 |   1 |   3 |   5 |    1
   8 |   1 |   6 |   8 |    1
   9 |   1 |   5 |   7 |    1
  10 |   2 |   5 |   8 |    1
  11 |   2 |   6 |   9 |    1
  12 |   2 |   9 |  16 |    1
  13 |   2 |   4 |   3 |    1
  14 |   2 |   3 |   5 |    1
  15 |   2 |   6 |  11 |  0.5
(15 rows)

Las consultas utilizan la red Datos Muestra .

Problemas conocidos

Introducción

el código pgr_trsp tiene problemas que aún no se están solucionando, pero a medida que pasa el tiempo y se agrega nueva funcionalidad a pgRouting, hay contenedores para ocultar los problemas, no para solucionarlos.

Para mayor claridad en las consultas:

  • _pgr_trsp (internal_function) es el código original

  • pgr_trsp (minúscula) representa el contenedor que convoca al código original

  • pgr_TRSP (mayúsculas) representa el contenedor que convoca a la función de reemplazo. Dependiendo de esa función, puede ser:

    • pgr_dijkstra

    • pgr_dijkstraVia

    • pgr_withPoints

    • _pgr_withPointsVia (función interna)

Las restricciones

La restricción utilizada en los ejemplos no tiene que ver nada con el grafo:

  • Ningún vértice tiene id: 25, 32 o 33

  • Ninguna arista tiene id: 25, 32 o 33

Se asigna una restricción como:

SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path;
 to_cost | target_id | via_path
---------+-----------+----------
     100 |        25 | 32, 33
(1 row)

El código back-end tiene la misma restricción que la siguiente

SELECT 1 AS id, 100::float AS cost, 25::INTEGER AS target_id, ARRAY[33, 32, 25] AS path;
 id | cost | target_id |    path
----+------+-----------+------------
  1 |  100 |        25 | {33,32,25}
(1 row)

por lo tanto, la ruta más corta esperado es como si no hubiera ninguna restricción involucrada

La versión de la firma «Vértices»

pgr_trsp(sql text, source integer, target integer,
         directed boolean, has_rcost boolean [,restrict_sql text]);

Diferentes formas de representar “ninguna ruta encontrada”

  • A veces se representa con EMPTY SET ninguna ruta encontrada

  • A veces representa con ERROR ninguna ruta encontrada

Se devuelve EMPTY SET para representar ninguna ruta encontrada

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 15, true, true
);
 seq | id1 | id2 | cost
-----+-----+-----+------
(0 rows)

pgr_trsp invoca pgr_dijkstra cuando no hay restricciones que devuelvan EMPTY SET cuando no se encuentra una ruta

SELECT * FROM pgr_dijkstra(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 15
);
 seq | path_seq | node | edge | cost | agg_cost
-----+----------+------+------+------+----------
(0 rows)

Se producirá una EXCEPCIÓN para representar ninguna ruta encontrada

SELECT * FROM pgr_trsp(
     $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
     1, 15, true, true,
     $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
ERROR:  Error computing path: Path Not Found

pgr_trsp utiliza el código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, lo que producirá una EXCEPCIÓN para representar ninguna ruta encontrada.

Ruteo desde/hacia la misma ubicación

Al enrutar desde la ubicación \(1\) a la misma ubicación \(1\), no se necesita ninguna ruta para llegar al destino, pues ya está allí. Por lo tanto, se espera que devuelva un EMPTY SET o un EXCEPTION dependiendo de los parámetros

  • A veces se representa con EMPTY SET ninguna ruta encontrada (esperada)

  • A veces se representa con EXCEPCIÓNninguna ruta encontrada (esperada)

  • A veces se encuentra una ruta (no esperada)

Se devuelve el SET EMPTY esperado para representar ninguna ruta encontrada

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    1, 1,  true, true
);
 seq | id1 | id2 | cost
-----+-----+-----+------
(0 rows)

pgr_trsp convoca a pgr_dijkstra cuando no hay resctricciones que devuelvan el EMPTY SET esperado para representar ninguna ruta encontrada.

Devolver EXCEPTION esperada para representar ninguna ruta encontrada

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    14, 14, true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
ERROR:  Error computing path: Path Not Found

En este caso pgr_trsp llama al código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, en este caso ese código lanza la EXCEPCIÓN esperada

Devolver una ruta inesperado

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    1, 1, true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   1 |   1 |    1
   1 |   2 |   4 |    1
   2 |   5 |   8 |    1
   3 |   6 |   9 |    1
   4 |   9 |  16 |    1
   5 |   4 |   3 |    1
   6 |   3 |   2 |    1
   7 |   2 |   1 |    1
   8 |   1 |  -1 |    0
(9 rows)

En este caso pgr_trsp llama al código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, en este caso ese código encuentra una ruta inesperada.

Contradicciones de usuarios

pgr_trsp a diferencia de otras funciones de pgRouting no detecta automáticamente la existencia de la columna reverse_cost. Por lo tanto, tiene el parámetro has_rcost para verificar la existencia de la columna reverse_cost. Las contradicciones suceden:

  • Cuando falta reverse_cost, y la marca has_rcost se establece como verdadera

  • Cuando el reverse_cost existe, y el indicador has_rcost se establece en false

Cuando falta reverse_cost y el indicador has_rcost se configura como verdadero.

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table$$,
    2, 3, false, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
ERROR:  Error, reverse_cost is used, but query did't return 'reverse_cost' column

Se produce una EXCEPCIÓN.

Cuando el reverse_cost existe, y el indicador has_rcost se establece en false

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    2, 3, false, false,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   2 |   4 |    1
   1 |   5 |   8 |    1
   2 |   6 |   5 |    1
   3 |   3 |  -1 |    0
(4 rows)

La columna de reverse_cost será eliminada efectivamente y costará tiempo de ejecución

La versión de firma «Edges»

pgr_trsp(sql text, source_edge integer, source_pos float8,
         target_edge integer, target_pos float8,
         directed boolean, has_rcost boolean [,restrict_sql text]);

Diferentes formas de representar “ninguna ruta encontrada”

  • A veces se representa con EMPTY SET ninguna ruta encontrada

  • A veces se representa con EXCEPCIÓN ninguna ruta encontrada

Se devuelve EMPTY SET para representar ninguna ruta encontrada

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 17, 0.5, true, true
);
 seq | id1 | id2 | cost
-----+-----+-----+------
(0 rows)

pgr_trsp invoca pgr_withPoints - Propuesto cuando no hay restricciones que devuelvan EMPTY SET cuando no se encuentra una ruta

Se producirá una EXCEPCIÓN para representar ninguna ruta encontrada

SELECT * FROM _pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 17, 0.5, true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
ERROR:  Error computing path: Path Not Found

pgr_trsp utiliza el código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, lo que producirá una EXCEPCIÓN para representar ninguna ruta encontrada.

Rutas con igual número de vértices y aristas

Una ruta se conforma por N vértices y N - 1 aristas.

  • A veces devuelve N vértices y N - 1 aristas.

  • A veces se devuelven N - 1 vértices y N - 1 aristas.

Retorno de N vértices y N - 1 aristas.

SELECT * FROM pgr_TRSP(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 1, 0.8, true, true
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |  0.3
   1 |  -2 |  -1 |    0
(2 rows)

pgr_trsp convoca a pgr_withPoints - Propuesto cuando no hay restricciones que devuelvan el número correcto de filas que incluirán todos los vértices. La última fila tendrá un -1 en la columna de aristas para indicar que el número de arista es inválido para esa fila.

Retorno de N - 1 vrtices’y N - 1 aristas.

SELECT * FROM pgr_TRSP(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 1, 0.8, true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |  0.3
(1 row)

pgr_trsp utiliza el código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, y no devolverán el último vértice de la ruta.

Ruteo desde/hacia la misma ubicación

Al enrutar desde la misma arista y posición a la misma arista y posición, no se necesita ninguna ruta para llegar al destino, pues ya está allí. Por lo tanto, se espera que devuelva un EMPTY SET o una EXCEPTION dependiendo de los parámetros, ninguno de los cuales está sucediendo.

Una ruta con 2 vértices y coste de arista 0

SELECT * FROM pgr_TRSP(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 1, 0.5, true, true
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |    0
   1 |  -2 |  -1 |    0
(2 rows)

pgr_trsp convoca a pgr_withPoints - Propuesto configurando la primera \((arista, posición)\) con un diferente id de punto de la segunda \((arista, posición)\) haciendo de ellas diferentes puntos. Pero el costo usando la arista es de \(0\).

Una ruta con 1 vértice y coste de arista 0

SELECT * FROM pgr_TRSP(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    1, 0.5, 1, 0.5, true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |    0
(1 row)

pgr_trsp utiliza el código original cuando hay restricciones, incluso si no tienen nada que ver con el grafo, y no tendrán la fila para el vértice \(-2\).

Contradicciones de usuarios

pgr_trsp a diferencia de otras funciones de pgRouting no detecta automáticamente la existencia de la columna reverse_cost. Por lo tanto, tiene el parámetro has_rcost para verificar la existencia de la columna reverse_cost. Las contradicciones suceden:

  • Cuando falta reverse_cost, y la marca has_rcost se establece como verdadera

  • Cuando el reverse_cost existe, y el indicador has_rcost se establece en false

Cuando falta reverse_cost y el indicador has_rcost se configura como verdadero.

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost FROM edge_table$$,
    1, 0.5, 1, 0.8, false, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
ERROR:  Error, reverse_cost is used, but query did't return 'reverse_cost' column

Se produce una EXCEPCIÓN.

Cuando el reverse_cost existe, y el indicador has_rcost se establece en false

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    1, 0.5, 1, 0.8, false, false,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |  0.3
(1 row)

La columna de reverse_cost será eliminada efectivamente y costará tiempo de ejecución

Uso de una tabla de puntos de interés

Dado un conjunto de puntos de interés:

SELECT * FROM pointsOfInterest;
 pid |  x  |  y  | edge_id | side | fraction |                  the_geom                  |                  newpoint
-----+-----+-----+---------+------+----------+--------------------------------------------+--------------------------------------------
   1 | 1.8 | 0.4 |       1 | l    |      0.4 | 0101000000CDCCCCCCCCCCFC3F9A9999999999D93F | 010100000000000000000000409A9999999999D93F
   2 | 4.2 | 2.4 |      15 | r    |      0.4 | 0101000000CDCCCCCCCCCC10403333333333330340 | 010100000000000000000010403333333333330340
   3 | 2.6 | 3.2 |      12 | l    |      0.6 | 0101000000CDCCCCCCCCCC04409A99999999990940 | 0101000000CDCCCCCCCCCC04400000000000000840
   4 | 0.3 | 1.8 |       6 | r    |      0.3 | 0101000000333333333333D33FCDCCCCCCCCCCFC3F | 0101000000333333333333D33F0000000000000040
   5 | 2.9 | 1.8 |       5 | l    |      0.8 | 01010000003333333333330740CDCCCCCCCCCCFC3F | 01010000000000000000000840CDCCCCCCCCCCFC3F
   6 | 2.2 | 1.7 |       4 | b    |      0.7 | 01010000009A99999999990140333333333333FB3F | 01010000000000000000000040333333333333FB3F
(6 rows)

Uso de pgr_trsp

SELECT * FROM pgr_TRSP(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    (SELECT edge_id::INTEGER  FROM pointsOfInterest WHERE pid = 1),
    (SELECT fraction  FROM pointsOfInterest WHERE pid = 1),
    (SELECT edge_id::INTEGER  FROM pointsOfInterest WHERE pid = 6),
    (SELECT fraction  FROM pointsOfInterest WHERE pid = 6),
    true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |  -1 |   1 |  0.6
   1 |   2 |   4 |  0.7
(2 rows)

En pgr_trsp, para poder utilizar la información de la tabla:

  • Cada parámetro debe extraerse explícitamente de la tabla

  • Independientemente del punto pid valor original

    • siempre será -1 para el primer punto

    • siempre será -2 para el segundo punto

      • la fila que alcanza el punto -2 no se mostrará

Uso de pgr_withPoints - Propuesto

SELECT * FROM pgr_withPoints(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    $$SELECT pid, edge_id, fraction FROM pointsOfInterest$$,
    -1, -6
);
 seq | path_seq | node | edge | cost | agg_cost
-----+----------+------+------+------+----------
   1 |        1 |   -1 |    1 |  0.6 |        0
   2 |        2 |    2 |    4 |  0.7 |      0.6
   3 |        3 |   -6 |   -1 |    0 |      1.3
(3 rows)

Sugerencia: use pgr_withPoints - Propuesto cuando no hay restricciones de giro:

  • Los resultados son más completos

  • Los nombres de columna son significativos

Ruteo desde un vértice a un punto

Resolver una ruta más corta desde el vértice \(6\) a pid 1 usando una tabla de puntos de interés

Uso de pgr_trsp

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    8, 1,
    (SELECT edge_id::INTEGER  FROM pointsOfInterest WHERE pid = 1),
    (SELECT fraction  FROM pointsOfInterest WHERE pid = 1),
    true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   6 |   8 |    1
   1 |   5 |   4 |    1
   2 |   2 |   1 |  0.6
(3 rows)

  • El vértice 6 está en el borde 8 en 1 fracción

SELECT * FROM pgr_trsp(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost FROM edge_table$$,
    11, 0,
    (SELECT edge_id::INTEGER  FROM pointsOfInterest WHERE pid = 1),
    (SELECT fraction  FROM pointsOfInterest WHERE pid = 1),
    true, true,
    $$SELECT 100::float AS to_cost, 25::INTEGER AS target_id, '32, 33'::TEXT AS via_path$$
);
 seq | id1 | id2 | cost
-----+-----+-----+------
   0 |   6 |   8 |    1
   1 |   5 |   4 |    1
   2 |   2 |   1 |  0.6
(3 rows)

  • El vértice 6 es también borde 11 en 0 fracción

Uso de pgr_withPoints - Propuesto

SELECT * FROM pgr_withPoints(
    $$SELECT id::INTEGER, source::INTEGER, target::INTEGER, cost, reverse_cost  FROM edge_table$$,
    $$SELECT pid, edge_id, fraction FROM pointsOfInterest$$,
    6, -1
);
 seq | path_seq | node | edge | cost | agg_cost
-----+----------+------+------+------+----------
   1 |        1 |    6 |    8 |    1 |        0
   2 |        2 |    5 |    4 |    1 |        1
   3 |        3 |    2 |    1 |  0.6 |        2
   4 |        4 |   -1 |   -1 |    0 |      2.6
(4 rows)

Sugerencia: use pgr_withPoints - Propuesto cuando no hay restricciones de giro:

  • No es necesario elegir dónde se encuentra el vértice.

  • Los resultados son más completos

  • Los nombres de columna son significativos

Prototipos

pgr_trspViaVertices y pgr_trspViaEdges fueron añadidas como prototipos

Estas funciones utilizan las funciones pgr_trsp heredando todos los problemas mencionados anteriormente. Cuando no hay restricciones y tienen un problema de ruteo «vía» con vértices:

Ver también

Índices y tablas