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¶

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:

pgr_dijkstraVia - Propuesto

Ver también¶

Índices y tablas