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
int4Identificador del borde- source
int4Identificador del vértice inicial del borde- target
int4Identificador del vértice final del borde- Costo
float8Costo 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
directedyhas_rcostsonTrue(ver el comentario anterior sobre los costos negativos).
- source
int4identificador del nodo de partida- target
int4identificador del nodo de llegada- dirigido
trueSi la gráfica es direccionada- has_rcost
Si es
True, el camporeverse_costdel 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
float8restricción del costo de giro- target_id
int4identificador del borde donde se aplica la restricción- via_path
Lista de aristas
textseparadas por comas en el orden inverso derule
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
int4identificador del borde de partida- source_pos
float8fracción de 1 que define la posición del sobre el borde de partida.- target_edge
int4Identificador del borde de llegada- target_pos
float8fracció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 (
-1para el ultimo registro)- Costo
costo para atravesar desde el nodo
id1usando 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
int4Identificador del borde- source
int4Identificador del vértice inicial del borde- target
int4Identificador del vértice final del borde- Costo
float8Costo 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
directedyhas_rcostsonTrue(ver el comentario anterior sobre los costos negativos).
- vids
int4[]Un arreglo ordenado de NODE id la ruta irá de principio a fin.- dirigido
trueSi la gráfica es direccionada- has_rcost
Si es
True, el camporeverse_costdel 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
float8restricción del costo de giro- target_id
int4identificador 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
int4Un 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 (
-1para el ultimo registro)- Costo
costo para atravesar desde el nodo
id2usando el bordeid3hasta 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: