0 AND NOT a.attisdropped ; IF existing_type IS NULL THEN EXECUTE format( 'ALTER TABLE %I.%I ADD COLUMN %I %s', _schema_name, _table_name, field.name, field.type ); field_status = 'added'; ELSIF existing_type = field.type THEN field_status = 'already exists'; ELSE -- Do not modify an existing field with another type field_status = format('already exists with the type %s', existing_type); END IF; RETURN NEXT; END LOOP; RETURN; END;]]> 0 THEN -- First update previous and next edges -- previous SET LOCAL road.graph.edge.ref.calc.disabled = 'yes'; UPDATE road_graph.edges AS e SET next_edge_id = ( SELECT s.id FROM road_graph.edges AS s WHERE s.id = OLD.next_edge_id ) WHERE e.next_edge_id = OLD.id ; -- next UPDATE road_graph.edges AS e SET previous_edge_id = ( SELECT s.id FROM road_graph.edges AS s WHERE s.id = OLD.previous_edge_id ) WHERE e.previous_edge_id = OLD.id ; -- Set back the value SET LOCAL road.graph.edge.ref.calc.disabled = 'no'; -- Calculate references IF raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% AFTER EDGE % N° %, update all road edges references: %', REPEAT(' ', pg_trigger_depth()::INTEGER), TG_OP, OLD.id, update_edge_references_result::text ; END IF; SELECT INTO update_edge_references_result road_graph.update_edge_references(OLD.road_code, NULL) ; END IF; RETURN OLD; END;]]> 0 THEN DELETE FROM road_graph.edges AS t WHERE t.id = ANY(attached_edge_ids) AND t.start_node = NEW.id AND t.end_node = NEW.id ; END IF; -- Split edges under the node if needed FOR edge_under_node IN SELECT -- we must pass all the fields -- to be able to copy/paste attributes data from the original edge -- when spliting it t.* FROM road_graph.edges AS t WHERE True -- Do not split the edges having the value True in no_intersection_cutting, -- except if the node is the extremity of an edge being created or moved -- (for example a new access road arriving in the middle of a highway edge) AND ( NOT Coalesce(t.no_intersection_cutting, False) OR is_edge_extremity ) -- edge is close to the node AND ST_DWithin(t.geom, NEW.geom, 0.50) -- but node is far enough from the start and end points AND NOT ST_DWithin(ST_StartPoint(t.geom), NEW.geom, 0.50) AND NOT ST_DWithin(ST_EndPoint(t.geom), NEW.geom, 0.50) ORDER BY t.geom <-> NEW.geom LOOP IF edge_under_node.id IS NOT NULL THEN IF raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% AFTER NODE % n° % %, found nearby edge % -> should split it', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, ST_AsText(NEW.geom), edge_under_node.id ; END IF; IF raise_notice IN ('debug') THEN RAISE NOTICE 'EDGE TO BE SPLIT'; RAISE NOTICE '%', to_json(edge_under_node); END IF; SELECT INTO id_new_edge split_edge_by_node FROM road_graph.split_edge_by_node( -- edge edge_under_node, -- node NEW, -- minimum distance from line 0.50::real, -- maximum distance from start & end points 0.50::real ); IF raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% AFTER NODE % n° % %, New edge created from split: %', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, ST_AsText(NEW.geom), id_new_edge ; END IF; END IF; END LOOP; RETURN NEW; END;]]> use it', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, extremity_node.node_id ; END IF; -- Update the geometry NEW.geom = ST_SetPoint(NEW.geom, 0, extremity_node.node_geom); -- Update the node ID in upstream attribute NEW.start_node = extremity_node.node_id; ELSIF extremity_node.is_created THEN NEW.start_node = extremity_node.node_id; IF NEW.start_node IS NOT NULL AND raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% BEFORE edge % n° %, upstream node created : % %', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, NEW.start_node, ST_AsText(extremity_node.node_geom) ; END IF; END IF; -- downstream node SELECT INTO extremity_node * FROM road_graph.get_or_create_edge_node( end_point, TG_OP = 'INSERT' OR NEW.end_node IS NULL ); IF extremity_node.node_id IS NOT NULL AND NOT extremity_node.is_created THEN IF raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% BEFORE edge % n° %, downstream node NOT NULL : % -> use it', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, extremity_node.node_id ; END IF; -- Update the geometry NEW.geom = ST_SetPoint(NEW.geom, ST_NPoints(NEW.geom) - 1, extremity_node.node_geom); -- Update the node ID in downstream attribute NEW.end_node = extremity_node.node_id; ELSIF extremity_node.is_created THEN NEW.end_node = extremity_node.node_id; IF NEW.end_node IS NOT NULL AND raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% BEFORE edge % n° %, downstream node created : % %', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, NEW.end_node, ST_AsText(extremity_node.node_geom) ; END IF; END IF; END IF; -- Calculate previous_edge_id and next_edge_id values -- for touching edges if the road_code has not changed IF NOT is_roundabout AND NOT has_changed_road_code THEN IF NEW.previous_edge_id IS NULL THEN -- Get the previous edge NEW.previous_edge_id = ( SELECT e.id FROM road_graph.edges AS e WHERE e.road_code = NEW.road_code AND e.end_node = NEW.start_node -- not the edge itself, whose old row is still in the table, for example when it is reversed AND e.id != NEW.id ORDER BY e.id LIMIT 1 ); END IF; IF NEW.next_edge_id IS NULL THEN -- Get the next edge NEW.next_edge_id = ( SELECT e.id FROM road_graph.edges AS e WHERE e.road_code = NEW.road_code AND e.start_node = NEW.end_node -- not the edge itself, whose old row is still in the table, for example when it is reversed AND e.id != NEW.id ORDER BY e.id LIMIT 1 ); END IF; END IF; -- Move marker 0 if needed -- If the first edge of the road has changed -- move it to the start_point of the changed geometry -- The marker 0 is not moved when the geometry has only been reversed: it stays at the start of the road IF TG_OP = 'UPDATE' AND NOT is_roundabout AND NOT has_changed_road_code AND NOT is_reversed AND OLD.start_abscissa = 0 AND NEW.start_abscissa = 0 AND OLD.start_cumulative = 0 AND NEW.start_cumulative = 0 AND OLD.start_marker = 0 AND NEW.start_marker = 0 AND OLD.road_code = NEW.road_code AND NOT ST_Equals(ST_StartPoint(NEW.geom), ST_StartPoint(OLD.geom)) THEN -- Do not run the function update_edge_references -- on the road triggered inside the after_marker_insert_or_update_or_delete -- trigger since it will already been triggered with the edge geometry change SET LOCAL road.graph.edge.ref.calc.disabled = 'yes'; UPDATE road_graph.markers AS m SET geom = ST_StartPoint(NEW.geom) WHERE m.road_code = NEW.road_code AND m.code = 0 AND ST_Equals(m.geom, ST_StartPoint(OLD.geom)) ; SET LOCAL road.graph.edge.ref.calc.disabled = 'no'; END IF; -- Calculate references -- They are not calculated for an UPDATE: -- * if the trigger after_edge_insert_or_update will calculate again the references -- of all the edges of the road (same condition as in this trigger function): -- the references calculated here would be overwritten, -- * or if the geometry, the road and the references have not been changed, for example -- when only another field has been modified: the references are still right. -- They are always calculated for an INSERT: the start cumulative is used to order -- the edges of the road (see get_ordered_edges) references_calculated_after = False; references_unchanged = False; IF TG_OP = 'UPDATE' THEN references_calculated_after = ( ( NOT ST_OrderingEquals(OLD.geom, NEW.geom) OR Coalesce(OLD.previous_edge_id, -1) != NEW.previous_edge_id OR Coalesce(OLD.next_edge_id, -1) != NEW.next_edge_id ) IS TRUE AND road_graph.get_current_setting('road.graph.edge.ref.calc.disabled', 'no') = 'no' ); references_unchanged = ( ST_OrderingEquals(OLD.geom, NEW.geom) IS TRUE AND OLD.road_code = NEW.road_code AND ( NEW.start_marker, NEW.start_abscissa, NEW.start_cumulative, NEW.end_marker, NEW.end_abscissa, NEW.end_cumulative ) IS NOT DISTINCT FROM ( OLD.start_marker, OLD.start_abscissa, OLD.start_cumulative, OLD.end_marker, OLD.end_abscissa, OLD.end_cumulative ) ); END IF; IF NOT is_roundabout AND NOT references_calculated_after AND NOT references_unchanged THEN BEGIN -- start point SELECT INTO start_references road_graph.get_reference_from_point(start_point, NEW.road_code) AS ref ; NEW.start_marker = (start_references->>'marker_code')::text::integer; NEW.start_abscissa = (start_references->>'abscissa')::text::real; NEW.start_cumulative = (start_references->>'cumulative')::text::real; -- end point SELECT INTO end_references road_graph.get_reference_from_point(end_point, NEW.road_code) AS ref ; NEW.end_marker = (end_references->>'marker_code')::text::integer; NEW.end_abscissa = (end_references->>'abscissa')::text::real; NEW.end_cumulative = (end_references->>'cumulative')::text::real; EXCEPTION WHEN OTHERS THEN IF raise_notice IN ('info', 'debug') THEN GET STACKED DIAGNOSTICS v_sqlstate = returned_sqlstate, v_message = message_text, v_context = pg_exception_context ; RAISE NOTICE '% BEFORE edge % n° %, NEW references NOT calculated, error = %', repeat(' ', pg_trigger_depth()::integer), TG_OP, NEW.id, v_sqlstate || ' - ' || v_message ; END IF; END; END IF; RETURN NEW; END;]]> >'road_code'), '' ) ); end_references = road_graph.get_reference_from_point( CASE WHEN lower(GeometryType(NEW.geom)) = 'linestring' THEN ST_EndPoint(NEW.geom) -- hopefully the last part is really the end part of the multilinestring ELSE ST_EndPoint(ST_GeometryN(NEW.geom, ST_NumGeometries(NEW.geom))) END, Nullif( trim(new_jsonb->>'road_code'), '' ) ); -- The references of the managed lines follow the road direction (start before end), -- like in the function update_table_references_from_geometries: -- invert start and end if the line is digitized in the opposite direction of the road IF ( (start_references->>'marker_code')::integer, (start_references->>'abscissa')::real ) > ( (end_references->>'marker_code')::integer, (end_references->>'abscissa')::real ) THEN SELECT end_references, start_references INTO start_references, end_references; END IF; -- Update the NEW object with the given references -- road_code - keep object road_code intact if it is not empty NEW.road_code = CASE WHEN Coalesce(NEW.road_code, '') != '' THEN NEW.road_code ELSE start_references->>'road_code' END; -- start_marker_code IF new_jsonb ? 'start_marker_code' THEN NEW.start_marker_code = (start_references->>'marker_code')::int; END IF; -- start_abscissa IF new_jsonb ? 'start_abscissa' THEN NEW.start_abscissa = (start_references->>'abscissa')::real; END IF; -- start_cumulative IF new_jsonb ? 'start_cumulative' THEN NEW.start_cumulative = (start_references->>'cumulative')::real; END IF; -- end_marker_code IF new_jsonb ? 'end_marker_code' THEN NEW.end_marker_code = (end_references->>'marker_code')::int; END IF; -- end_abscissa IF new_jsonb ? 'end_abscissa' THEN NEW.end_abscissa = (end_references->>'abscissa')::real; END IF; -- end_cumulative IF new_jsonb ? 'end_cumulative' THEN NEW.end_cumulative = (end_references->>'cumulative')::real; END IF; -- offset IF new_jsonb ? 'offset' THEN NEW.offset = Coalesce((start_references->>'offset')::real, 0.0::real); END IF; -- side IF new_jsonb ? 'side' THEN NEW.side = Coalesce(start_references->>'side', 'right'); END IF; ELSE -- POINT point_references = road_graph.get_reference_from_point( NEW.geom, Nullif( trim(new_jsonb->>'road_code'), '' ) ); -- Update the NEW object with the given references -- road_code - keep object road_code intact if it is not empty NEW.road_code = CASE WHEN Coalesce(NEW.road_code, '') != '' THEN NEW.road_code ELSE point_references->>'road_code' END; -- marker_code IF new_jsonb ? 'marker_code' THEN NEW.marker_code = (point_references->>'marker_code')::int; END IF; -- abscissa IF new_jsonb ? 'abscissa' THEN NEW.abscissa = (point_references->>'abscissa')::real; END IF; -- cumulative IF new_jsonb ? 'cumulative' THEN NEW.cumulative = (point_references->>'cumulative')::real; END IF; -- offset IF new_jsonb ? 'offset' THEN NEW.offset = Coalesce((point_references->>'offset')::real, 0.0::real); END IF; -- side IF new_jsonb ? 'side' THEN NEW.side = Coalesce(point_references->>'side', 'right'); END IF; END IF; RETURN NEW; END;]]> graph_check.code, '{}'::jsonb), issues_count; GET DIAGNOSTICS check_issues_count = ROW_COUNT; issues_count = issues_count + check_issues_count; END LOOP; RETURN; END;]]> >'tolerance')::real, 1.0); BEGIN RETURN QUERY WITH -- Pairs of close nodes, not linked by an edge: a short edge is found by another check. -- The pairs are found in the nodes table, to use its spatial index close_nodes AS ( SELECT a.id AS a_id, b.id AS b_id, a.geom AS a_geom, b.geom AS b_geom FROM road_graph.nodes AS a JOIN road_graph.nodes AS b ON a.id < b.id AND ST_DWithin(a.geom, b.geom, tolerance) WHERE NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE (e.start_node = a.id AND e.end_node = b.id) OR (e.start_node = b.id AND e.end_node = a.id) ) ), -- Edges and road codes of the nodes of the pairs pairs AS ( SELECT c.*, Coalesce(ae.edge_ids, '{}') AS a_edge_ids, Coalesce(be.edge_ids, '{}') AS b_edge_ids, Coalesce(ae.road_codes, '{}') || Coalesce(be.road_codes, '{}') AS pair_road_codes FROM close_nodes AS c CROSS JOIN LATERAL ( SELECT array_agg(e.id ORDER BY e.id) AS edge_ids, array_agg(DISTINCT e.road_code) AS road_codes FROM road_graph.edges AS e WHERE c.a_id IN (e.start_node, e.end_node) ) AS ae CROSS JOIN LATERAL ( SELECT array_agg(e.id ORDER BY e.id) AS edge_ids, array_agg(DISTINCT e.road_code) AS road_codes FROM road_graph.edges AS e WHERE c.b_id IN (e.start_node, e.end_node) ) AS be ), -- Node to keep: the node with the most edges, so that the fewest edges are moved, -- or else the node with the lowest id (the first node of the pair), i.e. the oldest node issues AS ( SELECT p.*, CASE WHEN keep_a THEN p.a_id ELSE p.b_id END AS keep_id, CASE WHEN keep_a THEN p.a_geom ELSE p.b_geom END AS keep_geom, CASE WHEN keep_a THEN p.b_id ELSE p.a_id END AS remove_id, CASE WHEN keep_a THEN p.b_geom ELSE p.a_geom END AS remove_geom, -- Road code of the issue: the first road code of the edges of the two nodes (SELECT min(c) FROM unnest(p.pair_road_codes) AS c) AS issue_road_code FROM pairs AS p, LATERAL (SELECT cardinality(p.a_edge_ids) >= cardinality(p.b_edge_ids) AS keep_a) AS k WHERE _road_codes IS NULL OR p.pair_road_codes && _road_codes ) SELECT 'G03'::text, 'Nodes close to each other'::text, 'error'::text, i.issue_road_code, (SELECT array_agg(DISTINCT x ORDER BY x) FROM unnest(i.a_edge_ids || i.b_edge_ids) AS x), ARRAY[i.keep_id, i.remove_id], NULL::integer[], jsonb_build_object( 'road_codes', (SELECT jsonb_agg(DISTINCT c ORDER BY c) FROM unnest(i.pair_road_codes) AS c), 'distance', round(ST_Distance(i.a_geom, i.b_geom)::numeric, 2) ), 'merge_nodes'::text, jsonb_build_object( 'keep_node_id', i.keep_id, 'remove_node_id', i.remove_id ), i.keep_geom, CASE WHEN ST_Equals(i.a_geom, i.b_geom) THEN NULL ELSE ST_MakeLine(i.remove_geom, i.keep_geom) END FROM issues AS i ORDER BY i.issue_road_code, i.a_id, i.b_id ; END;]]> >'crossing_fix_action', ''); BEGIN IF crossing_fix_action NOT IN ('cut_edges', 'mark_as_bridge') THEN RAISE EXCEPTION 'The option crossing_fix_action of the check G01 must be cut_edges or mark_as_bridge, not %', crossing_fix_action; END IF; RETURN QUERY WITH -- Points where two edges cross or touch each other. -- The edges which must not be cut, for example on a bridge, are ignored crossings AS ( SELECT a.id AS a_id, b.id AS b_id, a.road_code AS a_road_code, b.road_code AS b_road_code, a.geom AS a_geom, b.geom AS b_geom, (ST_Dump(ST_CollectionExtract(ST_Intersection(a.geom, b.geom), 1))).geom AS point FROM road_graph.edges AS a JOIN road_graph.edges AS b ON a.id < b.id AND ST_Intersects(a.geom, b.geom) WHERE NOT Coalesce(a.no_intersection_cutting, False) AND NOT Coalesce(b.no_intersection_cutting, False) AND ( _road_codes IS NULL OR a.road_code = ANY(_road_codes) OR b.road_code = ANY(_road_codes) ) ), -- Is the point at the start or end of each edge ends AS ( SELECT c.*, ST_DWithin(c.point, ST_StartPoint(c.a_geom), tolerance) OR ST_DWithin(c.point, ST_EndPoint(c.a_geom), tolerance) AS is_a_end, ST_DWithin(c.point, ST_StartPoint(c.b_geom), tolerance) OR ST_DWithin(c.point, ST_EndPoint(c.b_geom), tolerance) AS is_b_end FROM crossings AS c ), -- Keep the points which are not at the start or end of both edges: -- at least one of the edges must be split there. -- If the point is at the start or end of one edge, the edges touch each other: they are surely connected. -- Else they cross each other, maybe on a bridge issues AS ( SELECT e.*, e.is_a_end OR e.is_b_end AS is_touching FROM ends AS e WHERE NOT (e.is_a_end AND e.is_b_end) ), -- Direction of each edge at the crossing point, from its points 1 m before and after, -- to get the angle between the edges: it helps to find the bridges directions AS ( SELECT i.*, degrees(ST_Azimuth( ST_LineInterpolatePoint(i.a_geom, greatest(a.position - 1 / ST_Length(i.a_geom), 0)), ST_LineInterpolatePoint(i.a_geom, least(a.position + 1 / ST_Length(i.a_geom), 1)) )) AS a_azimuth, degrees(ST_Azimuth( ST_LineInterpolatePoint(i.b_geom, greatest(b.position - 1 / ST_Length(i.b_geom), 0)), ST_LineInterpolatePoint(i.b_geom, least(b.position + 1 / ST_Length(i.b_geom), 1)) )) AS b_azimuth FROM issues AS i, -- Position of the crossing point along each edge, from 0 to 1 LATERAL (SELECT ST_LineLocatePoint(i.a_geom, i.point) AS position) AS a, LATERAL (SELECT ST_LineLocatePoint(i.b_geom, i.point) AS position) AS b ) SELECT 'G01'::text, 'Crossing edges without node'::text, 'error'::text, d.a_road_code, ARRAY[d.a_id, d.b_id], -- Existing node close to the crossing point, not used by the edges ( SELECT array_agg(n.id ORDER BY n.id) FROM road_graph.nodes AS n WHERE ST_DWithin(n.geom, d.point, tolerance) ), NULL::integer[], jsonb_build_object( 'crossing_type', CASE WHEN d.is_touching THEN 'touching' ELSE 'crossing' END, 'road_codes', jsonb_build_array(d.a_road_code, d.b_road_code), 'road_classes', jsonb_build_array(ra.road_class, rb.road_class), -- Angle between the two edges, from 0 (parallel) to 90 degrees (perpendicular) 'angle', round((90 - abs(90 - mod((abs(d.a_azimuth - d.b_azimuth))::numeric, 180)))::numeric, 1) ), CASE WHEN d.is_touching THEN 'cut_edges' ELSE crossing_fix_action END, jsonb_build_object( 'point', ST_AsEWKT(d.point), 'edge_ids', jsonb_build_array(d.a_id, d.b_id) ), d.point, ST_Collect(d.a_geom, d.b_geom) FROM directions AS d LEFT JOIN road_graph.roads AS ra ON ra.road_code = d.a_road_code LEFT JOIN road_graph.roads AS rb ON rb.road_code = d.b_road_code ORDER BY d.a_road_code, d.a_id, d.b_id ; END;]]> >'tolerance')::real, 1.0); -- Distance under which the marker is at the start of the road: the coordinates are rounded to 10 cm start_tolerance real = 0.05; BEGIN RETURN QUERY WITH -- First marker of each road, except the roundabouts: the marker with the lowest code and abscissa, -- which can be virtual first_markers AS ( SELECT DISTINCT ON (m.road_code) m.id, m.road_code, m.code, m.abscissa, m.is_virtual, m.geom FROM road_graph.markers AS m JOIN road_graph.roads AS r ON r.road_code = m.road_code WHERE r.road_type != 'roundabout' AND (_road_codes IS NULL OR m.road_code = ANY(_road_codes)) ORDER BY m.road_code, m.code, m.abscissa, m.id ), -- First edge of each road: the edge without previous edge, with the lowest start cumulative first_edges AS ( SELECT DISTINCT ON (e.road_code) e.id, e.road_code, e.geom, e.start_node, e.start_marker FROM road_graph.edges AS e WHERE _road_codes IS NULL OR e.road_code = ANY(_road_codes) ORDER BY e.road_code, (e.previous_edge_id IS NOT NULL), e.start_cumulative NULLS LAST, e.id ), -- First markers which are not at the start of the first edge of their road issues AS ( SELECT m.id AS marker_id, m.road_code, m.code, m.abscissa, m.is_virtual, m.geom AS marker_geom, e.id AS edge_id, e.start_node, e.start_marker, ST_StartPoint(e.geom) AS start_point, ST_Distance(m.geom, ST_StartPoint(e.geom)) AS distance, -- Position of the marker along the first edge, from its start ST_LineLocatePoint(e.geom, m.geom) * ST_Length(e.geom) AS position FROM first_markers AS m JOIN first_edges AS e ON e.road_code = m.road_code WHERE NOT ST_DWithin(m.geom, ST_StartPoint(e.geom), start_tolerance) ) SELECT 'G09'::text, 'First marker not at the start of the road'::text, -- The start of the first edge has no reference when the marker is after it CASE WHEN i.start_marker IS NULL THEN 'error' ELSE 'warning' END, i.road_code, ARRAY[i.edge_id], ARRAY[i.start_node], ARRAY[i.marker_id], jsonb_build_object( 'marker_code', i.code, 'marker_abscissa', i.abscissa, 'is_virtual', i.is_virtual, 'distance', round(i.distance::numeric, 2), 'position_on_edge', round(i.position::numeric, 2), 'has_start_reference', i.start_marker IS NOT NULL ), CASE WHEN i.distance <= tolerance THEN 'move_marker' ELSE NULL END, CASE WHEN i.distance <= tolerance THEN jsonb_build_object( 'marker_id', i.marker_id, 'edge_id', i.edge_id, 'point', ST_AsEWKT(i.start_point) ) ELSE NULL END, i.marker_geom, ST_MakeLine(i.marker_geom, i.start_point) FROM issues AS i ORDER BY i.road_code ; END;]]> >'marker_tolerance')::real, 50.0); -- Tolerance on the positions of the markers: two markers at the same point can have -- slightly different positions, for example at the end of an edge and at the start of the next edge position_tolerance real = 1.0; road record; -- Markers of the road, sorted by code and abscissa marker_ids_list integer[]; marker_codes integer[]; marker_abscissas real[]; marker_virtuals boolean[]; marker_geoms geometry[]; marker_edge_ids integer[]; marker_positions double precision[]; marker_count integer; -- Longest sequence of markers in the order of their position, ending at each marker sequence_lengths integer[]; previous_indexes integer[]; best_index integer; in_order boolean[]; -- Previous and next markers in the order of the road, around a marker out of this order previous_index integer; next_index integer; i integer; j integer; BEGIN -- Roads with markers, except the roundabouts FOR road IN SELECT DISTINCT m.road_code FROM road_graph.markers AS m JOIN road_graph.roads AS r ON r.road_code = m.road_code WHERE r.road_type != 'roundabout' AND (_road_codes IS NULL OR m.road_code = ANY(_road_codes)) ORDER BY m.road_code LOOP -- Markers of the road in the order of their code and abscissa, with their position along the road: -- the cumulative length at their closest edge of the road SELECT array_agg(x.id ORDER BY x.code, x.abscissa, x.id), array_agg(x.code ORDER BY x.code, x.abscissa, x.id), array_agg(x.abscissa ORDER BY x.code, x.abscissa, x.id), array_agg(x.is_virtual ORDER BY x.code, x.abscissa, x.id), array_agg(x.geom ORDER BY x.code, x.abscissa, x.id), array_agg(x.edge_id ORDER BY x.code, x.abscissa, x.id), array_agg(x.position ORDER BY x.code, x.abscissa, x.id) INTO marker_ids_list, marker_codes, marker_abscissas, marker_virtuals, marker_geoms, marker_edge_ids, marker_positions FROM ( SELECT m.id, m.code, m.abscissa, m.is_virtual, m.geom, c.id AS edge_id, c.distance, c.start_cumulative + ST_LineLocatePoint(c.geom, m.geom) * ST_Length(c.geom) AS position FROM road_graph.markers AS m LEFT JOIN LATERAL ( SELECT e.id, e.geom, e.start_cumulative, ST_Distance(e.geom, m.geom) AS distance FROM road_graph.edges AS e WHERE e.road_code = m.road_code AND ST_DWithin(e.geom, m.geom, marker_tolerance) ORDER BY ST_Distance(e.geom, m.geom), e.id LIMIT 1 ) AS c ON True WHERE m.road_code = road.road_code ) AS x ; marker_count = cardinality(marker_ids_list); -- Longest sequence of markers whose positions increase with their code and abscissa: -- the markers out of this sequence are not in the order of the road sequence_lengths = array_fill(0, ARRAY[marker_count]); previous_indexes = array_fill(0, ARRAY[marker_count]); in_order = array_fill(False, ARRAY[marker_count]); best_index = 0; FOR i IN 1..marker_count LOOP CONTINUE WHEN marker_positions[i] IS NULL; sequence_lengths[i] = 1; FOR j IN 1..i - 1 LOOP IF marker_positions[j] IS NOT NULL -- Two markers can be at the same position, for example a virtual marker -- and the marker of the next code, with the same reference AND marker_positions[j] <= marker_positions[i] + position_tolerance AND sequence_lengths[j] + 1 > sequence_lengths[i] THEN sequence_lengths[i] = sequence_lengths[j] + 1; previous_indexes[i] = j; END IF; END LOOP; IF best_index = 0 OR sequence_lengths[i] > sequence_lengths[best_index] THEN best_index = i; END IF; END LOOP; i = best_index; WHILE i > 0 LOOP in_order[i] = True; i = previous_indexes[i]; END LOOP; -- One issue for each marker far from the road, on an edge without reference, -- or out of the order of the road FOR i IN 1..marker_count LOOP CONTINUE WHEN in_order[i]; previous_index = (SELECT k FROM generate_series(i - 1, 1, -1) AS k WHERE in_order[k] LIMIT 1); next_index = (SELECT k FROM generate_series(i + 1, marker_count) AS k WHERE in_order[k] LIMIT 1); check_code = 'G10'; check_title = 'Markers not in the order of the road'; severity = 'error'; road_code = road.road_code; edge_ids = CASE WHEN marker_edge_ids[i] IS NULL THEN NULL ELSE ARRAY[marker_edge_ids[i]] END; node_ids = NULL; marker_ids = ARRAY[marker_ids_list[i]]; details = jsonb_build_object( 'issue_type', CASE WHEN marker_edge_ids[i] IS NULL THEN 'far_from_road' WHEN marker_positions[i] IS NULL THEN 'edge_without_reference' ELSE 'order' END, 'marker_code', marker_codes[i], 'marker_abscissa', marker_abscissas[i], 'is_virtual', marker_virtuals[i], 'position', round(marker_positions[i]::numeric, 1), -- Previous and next markers by code which are in the order of the road 'previous_marker_code', marker_codes[previous_index], 'previous_marker_position', round(marker_positions[previous_index]::numeric, 1), 'next_marker_code', marker_codes[next_index], 'next_marker_position', round(marker_positions[next_index]::numeric, 1) ); fix_action = NULL; fix_params = NULL; geom = marker_geoms[i]; geom_detail = NULL; RETURN NEXT; END LOOP; END LOOP; RETURN; END;]]> >'tolerance')::real, 30.0); -- Minimum length along which the two edges are parallel min_length real = Coalesce((_options->>'min_length')::real, 10.0); BEGIN RETURN QUERY WITH -- Pairs of edges of the same road less than the tolerance from each other, not connected by a node, -- and the parts of each edge less than the tolerance from the other edge. -- The roundabouts are ignored pairs AS ( SELECT a.road_code, a.id AS a_id, b.id AS b_id, a.geom AS a_geom, b.geom AS b_geom, ST_Distance(a.geom, b.geom) AS distance, -- The parts are segmentized, to locate their points along the other edge ST_Segmentize(ST_Intersection(a.geom, ST_Buffer(b.geom, tolerance)), 2) AS a_part, ST_Segmentize(ST_Intersection(b.geom, ST_Buffer(a.geom, tolerance)), 2) AS b_part FROM road_graph.edges AS a JOIN road_graph.edges AS b ON b.road_code = a.road_code AND b.id > a.id AND ST_DWithin(a.geom, b.geom, tolerance) JOIN road_graph.roads AS r ON r.road_code = a.road_code WHERE r.road_type != 'roundabout' AND (_road_codes IS NULL OR a.road_code = ANY(_road_codes)) AND NOT (ARRAY[a.start_node, a.end_node] && ARRAY[b.start_node, b.end_node]) ), -- Length of the other edge along which each part runs: the parts of two edges which only approach -- each other, for example the edges of a road on both sides of a roundabout, -- run along a very short length of the other edge spans AS ( SELECT p.*, ( SELECT (max(ST_LineLocatePoint(p.b_geom, d.geom)) - min(ST_LineLocatePoint(p.b_geom, d.geom))) * ST_Length(p.b_geom) FROM ST_DumpPoints(p.a_part) AS d ) AS a_span, ( SELECT (max(ST_LineLocatePoint(p.a_geom, d.geom)) - min(ST_LineLocatePoint(p.a_geom, d.geom))) * ST_Length(p.a_geom) FROM ST_DumpPoints(p.b_part) AS d ) AS b_span FROM pairs AS p WHERE ST_Length(p.a_part) >= min_length AND ST_Length(p.b_part) >= min_length ) SELECT 'G07'::text, 'Parallel edges of the same road'::text, 'warning'::text, s.road_code, ARRAY[s.a_id, s.b_id], NULL::integer[], NULL::integer[], jsonb_build_object( 'distance', round(s.distance::numeric, 2), 'parallel_length', round(least(s.a_span, s.b_span)::numeric, 1) ), NULL::text, NULL::jsonb, ST_ClosestPoint(s.a_geom, s.b_geom), ST_Collect(s.a_part, s.b_part) FROM spans AS s WHERE s.a_span >= min_length AND s.b_span >= min_length ORDER BY s.road_code, s.a_id, s.b_id ; END;]]> >'marker_tolerance')::real, 10.0); BEGIN RETURN QUERY WITH RECURSIVE -- Edges of the checked roads road_edges AS MATERIALIZED ( SELECT e.id, e.road_code, e.geom, ST_Length(e.geom) AS edge_length, r.road_type = 'roundabout' AS is_roundabout, -- Nodes of the start and end points of the edge. -- The geometry gives the direction of the edge: the start and end nodes -- may have not been swapped when the geometry has been reversed CASE WHEN ST_DWithin(ST_StartPoint(e.geom), sn.geom, 0.01) THEN e.start_node ELSE e.end_node END AS first_node, CASE WHEN ST_DWithin(ST_StartPoint(e.geom), sn.geom, 0.01) THEN e.end_node ELSE e.start_node END AS last_node FROM road_graph.edges AS e JOIN road_graph.roads AS r ON r.road_code = e.road_code JOIN road_graph.nodes AS sn ON sn.id = e.start_node WHERE (_road_codes IS NULL OR e.road_code = ANY(_road_codes)) -- The loops cannot be in the opposite direction of their neighbours AND e.start_node != e.end_node ), -- Start and end points of the edges, with the number of edges of the road at their node edge_ends AS MATERIALIZED ( SELECT x.*, count(*) OVER (PARTITION BY x.road_code, x.node_id) AS node_edge_count FROM ( SELECT e.id, e.road_code, e.first_node AS node_id, True AS is_first FROM road_edges AS e UNION ALL SELECT e.id, e.road_code, e.last_node AS node_id, False AS is_first FROM road_edges AS e ) AS x ), -- Walks along the sequences of edges of a road following each other: -- two edges follow each other at a node where there are only these two edges of the road. -- A walk starts from an end of a sequence (a node with one edge or more than two edges of the road), -- and follows the next edges. Each edge is walked in its direction (is_forward) or not. -- The walk carries the road code and the length of the edge, to join the next edge directly walks AS ( SELECT x.id AS walk_id, x.is_first AS is_walk_forward, x.id, x.road_code, e.edge_length, x.is_first AS is_forward, 1 AS edge_order, 0::double precision AS start_position, -- Node by which the walk leaves the edge CASE WHEN x.is_first THEN e.last_node ELSE e.first_node END AS exit_node, ARRAY[x.id] AS walked_ids FROM edge_ends AS x JOIN road_edges AS e ON e.id = x.id WHERE x.node_edge_count != 2 UNION ALL SELECT w.walk_id, w.is_walk_forward, n.id, n.road_code, e.edge_length, n.is_first, w.edge_order + 1, w.start_position + w.edge_length, CASE WHEN n.is_first THEN e.last_node ELSE e.first_node END, w.walked_ids || n.id FROM walks AS w JOIN edge_ends AS n ON n.road_code = w.road_code AND n.node_id = w.exit_node AND n.node_edge_count = 2 AND n.id != w.id JOIN road_edges AS e ON e.id = n.id WHERE NOT n.id = ANY(w.walked_ids) ), -- Last edge of each walk walk_ends AS ( SELECT w.walk_id, w.is_walk_forward, (array_agg(w.id ORDER BY w.edge_order DESC))[1] AS last_id FROM walks AS w GROUP BY w.walk_id, w.is_walk_forward ), -- Edges of each sequence. Each sequence is walked from its two ends: keep the walk starting -- from the edge with the lowest id, or for a sequence of one edge, the walk in the direction of the edge sequence_edges AS MATERIALIZED ( SELECT w.walk_id AS sequence_id, w.id, w.is_forward, w.edge_order, w.start_position, e.road_code, e.geom, e.edge_length, e.is_roundabout FROM walks AS w JOIN walk_ends AS we ON we.walk_id = w.walk_id AND we.is_walk_forward = w.is_walk_forward JOIN road_edges AS e ON e.id = w.id WHERE we.walk_id < we.last_id OR (we.walk_id = we.last_id AND we.is_walk_forward) ), -- Position of the markers of the road along the sequences, in the direction of the walk, -- from their closest edge of the sequence. The markers of the roundabouts are not used marker_positions AS ( SELECT se.sequence_id, m.id AS marker_id, m.code, m.abscissa, se.start_position + se.edge_length * CASE WHEN se.is_forward THEN ST_LineLocatePoint(se.geom, m.geom) ELSE 1 - ST_LineLocatePoint(se.geom, m.geom) END AS position FROM road_graph.markers AS m -- Closest edge of the road, found with the spatial index of the edges JOIN LATERAL ( SELECT e.id FROM road_graph.edges AS e WHERE e.road_code = m.road_code AND ST_DWithin(e.geom, m.geom, marker_tolerance) ORDER BY ST_Distance(e.geom, m.geom), e.id LIMIT 1 ) AS c ON True JOIN sequence_edges AS se ON se.id = c.id AND NOT se.is_roundabout WHERE _road_codes IS NULL OR m.road_code = ANY(_road_codes) ), -- Consecutive markers by code and abscissa: they must be in the direction of the road marker_pairs AS ( SELECT p.sequence_id, p.position < lead(p.position) OVER w AS is_increasing, p.position > lead(p.position) OVER w AS is_decreasing FROM marker_positions AS p WINDOW w AS (PARTITION BY p.sequence_id ORDER BY p.code, p.abscissa) ), -- Number of consecutive markers in the direction of the walk, and in the opposite direction marker_votes AS ( SELECT mp.sequence_id, count(*) FILTER (WHERE mp.is_increasing) AS increasing_count, count(*) FILTER (WHERE mp.is_decreasing) AS decreasing_count FROM marker_pairs AS mp GROUP BY mp.sequence_id ), -- Direction of each sequence: the direction of most of the consecutive markers, -- or else the direction of most of the length of the edges. -- The edges in the other direction are reversed sequence_directions AS ( SELECT s.sequence_id, -- Number of consecutive markers in the direction of the road, and in the opposite direction greatest(Coalesce(v.increasing_count, 0), Coalesce(v.decreasing_count, 0)) AS increasing_count, least(Coalesce(v.increasing_count, 0), Coalesce(v.decreasing_count, 0)) AS decreasing_count, CASE WHEN Coalesce(v.increasing_count, 0) != Coalesce(v.decreasing_count, 0) THEN 'markers' ELSE 'neighbours' END AS reason, CASE WHEN Coalesce(v.increasing_count, 0) > Coalesce(v.decreasing_count, 0) THEN True WHEN Coalesce(v.increasing_count, 0) < Coalesce(v.decreasing_count, 0) THEN False -- Without markers, the walk is in the direction of the road -- if most of the length of the edges is in the direction of the walk ELSE s.forward_length >= s.backward_length END AS is_walk_in_road_direction FROM ( SELECT se.sequence_id, Coalesce(sum(se.edge_length) FILTER (WHERE se.is_forward), 0) AS forward_length, Coalesce(sum(se.edge_length) FILTER (WHERE NOT se.is_forward), 0) AS backward_length FROM sequence_edges AS se GROUP BY se.sequence_id ) AS s LEFT JOIN marker_votes AS v ON v.sequence_id = s.sequence_id ), -- Reversed edges, and groups of consecutive reversed edges along each sequence: one issue for each group reversed_edges AS ( SELECT se.*, d.reason, d.increasing_count, d.decreasing_count, -- Order of the edge in the direction of the road CASE WHEN d.is_walk_in_road_direction THEN se.edge_order ELSE - se.edge_order END AS road_order, se.edge_order - row_number() OVER (PARTITION BY se.sequence_id ORDER BY se.edge_order) AS group_number FROM sequence_edges AS se JOIN sequence_directions AS d ON d.sequence_id = se.sequence_id WHERE se.is_forward != d.is_walk_in_road_direction ) SELECT 'G05'::text, 'Edges in the opposite direction of the road'::text, 'error'::text, r.road_code, array_agg(r.id ORDER BY r.road_order), NULL::integer[], NULL::integer[], jsonb_build_object( 'reason', min(r.reason), 'edge_count', count(*), 'length', round(sum(r.edge_length)::numeric, 1), 'markers_in_road_direction', max(r.increasing_count), 'markers_in_opposite_direction', max(r.decreasing_count) ), 'reverse_edges'::text, jsonb_build_object('edge_ids', array_agg(r.id ORDER BY r.road_order)), ST_LineInterpolatePoint((array_agg(r.geom ORDER BY r.road_order))[1], 0.5), ST_LineMerge(ST_Collect(r.geom)) FROM reversed_edges AS r GROUP BY r.road_code, r.sequence_id, r.group_number ORDER BY r.road_code, min(r.id) ; END;]]> 2 ), -- Direction of the edges at the node: the azimuth of the edges arriving at the node at their end, -- and of the edges leaving the node at their start, given by their geometry node_edges AS ( SELECT b.road_code, b.node_id, n.geom AS node_geom, x.id, x.geom, ST_DWithin(ST_EndPoint(x.geom), n.geom, 0.01) AS is_arriving, ST_DWithin(ST_StartPoint(x.geom), n.geom, 0.01) AS is_leaving, ST_Azimuth(ST_PointN(x.geom, ST_NPoints(x.geom) - 1), ST_EndPoint(x.geom)) AS end_azimuth, ST_Azimuth(ST_StartPoint(x.geom), ST_PointN(x.geom, 2)) AS start_azimuth FROM branch_nodes AS b JOIN road_graph.nodes AS n ON n.id = b.node_id JOIN edge_ends AS x ON x.road_code = b.road_code AND x.node_id = b.node_id ), -- Main line of the road at the node: the edge arriving at the node and the edge leaving it -- which are the most aligned. The other edges are the branches main_lines AS ( SELECT DISTINCT ON (a.road_code, a.node_id) a.road_code, a.node_id, a.id AS arriving_id, l.id AS leaving_id FROM node_edges AS a JOIN node_edges AS l ON l.road_code = a.road_code AND l.node_id = a.node_id AND l.id != a.id WHERE a.is_arriving AND l.is_leaving -- Deflection angle between the two edges, from 0 (aligned) to pi ORDER BY a.road_code, a.node_id, abs(mod((l.start_azimuth - a.end_azimuth + 3 * pi())::numeric, (2 * pi())::numeric) - pi()), a.id, l.id ) SELECT 'G06'::text, 'Road with branches'::text, 'error'::text, b.road_code, b.node_edge_ids, ARRAY[b.node_id], NULL::integer[], jsonb_build_object( 'edge_count', cardinality(b.node_edge_ids), 'main_edge_ids', CASE WHEN m.arriving_id IS NULL THEN '[]'::jsonb ELSE jsonb_build_array(m.arriving_id, m.leaving_id) END, 'branch_edge_ids', ( SELECT jsonb_agg(x ORDER BY x) FROM unnest(b.node_edge_ids) AS x WHERE x IS DISTINCT FROM m.arriving_id AND x IS DISTINCT FROM m.leaving_id ) ), NULL::text, NULL::jsonb, n.geom, ( SELECT ST_Collect(e.geom ORDER BY e.id) FROM road_graph.edges AS e WHERE e.id = ANY(b.node_edge_ids) AND e.id IS DISTINCT FROM m.arriving_id AND e.id IS DISTINCT FROM m.leaving_id ) FROM branch_nodes AS b JOIN road_graph.nodes AS n ON n.id = b.node_id LEFT JOIN main_lines AS m ON m.road_code = b.road_code AND m.node_id = b.node_id ORDER BY b.road_code, b.node_id ; END;]]> >'min_length')::real, 3.0); -- Length of an edge reduced to a point: the coordinates are rounded to 10 cm zero_length real = 0.10; BEGIN RETURN QUERY WITH -- Short edges, with the number of other edges at their start and end nodes short_edges AS ( SELECT e.id, e.road_code, e.start_node, e.end_node, e.geom, ST_Length(e.geom) AS edge_length, ( SELECT count(*) FROM road_graph.edges AS o WHERE o.id != e.id AND e.start_node IN (o.start_node, o.end_node) ) AS start_edge_count, ( SELECT count(*) FROM road_graph.edges AS o WHERE o.id != e.id AND e.end_node IN (o.start_node, o.end_node) ) AS end_edge_count, ( SELECT count(*) FROM road_graph.edges AS o WHERE o.road_code = e.road_code ) AS road_edge_count, -- The edges of the roundabouts, and the edges arriving at a roundabout or leaving it r.road_type = 'roundabout' OR EXISTS ( SELECT 1 FROM road_graph.edges AS o JOIN road_graph.roads AS ro ON ro.road_code = o.road_code WHERE ro.road_type = 'roundabout' AND o.id != e.id AND ARRAY[o.start_node, o.end_node] && ARRAY[e.start_node, e.end_node] ) AS is_roundabout_edge FROM road_graph.edges AS e JOIN road_graph.roads AS r ON r.road_code = e.road_code WHERE ST_Length(e.geom) < min_length AND (_road_codes IS NULL OR e.road_code = ANY(_road_codes)) ), -- The edges of the roundabouts, or arriving at a roundabout, are often short: they are ignored, -- unless they are reduced to a point. -- The node to keep is the node with the most edges, or else the node with the lowest id issues AS ( SELECT s.*, s.edge_length < zero_length AS is_zero_length, CASE WHEN s.start_edge_count > s.end_edge_count THEN True WHEN s.start_edge_count < s.end_edge_count THEN False ELSE s.start_node <= s.end_node END AS keep_start FROM short_edges AS s WHERE NOT s.is_roundabout_edge OR s.edge_length < zero_length ) SELECT 'G08'::text, 'Short edge'::text, CASE WHEN i.is_zero_length THEN 'error' ELSE 'warning' END, i.road_code, ARRAY[i.id], CASE WHEN i.keep_start THEN ARRAY[i.start_node, i.end_node] ELSE ARRAY[i.end_node, i.start_node] END, NULL::integer[], jsonb_build_object( 'length', round(i.edge_length::numeric, 2), 'start_edge_count', i.start_edge_count, 'end_edge_count', i.end_edge_count, 'is_roundabout_edge', i.is_roundabout_edge ), -- The only edge of a road is not removed: the road would not have any edge anymore CASE WHEN i.road_edge_count > 1 THEN 'collapse_edge' ELSE NULL END, CASE WHEN i.road_edge_count = 1 THEN NULL ELSE jsonb_build_object( 'edge_id', i.id, 'keep_node_id', CASE WHEN i.keep_start THEN i.start_node ELSE i.end_node END, 'remove_node_id', CASE WHEN i.keep_start THEN i.end_node ELSE i.start_node END ) END, ST_LineInterpolatePoint(i.geom, 0.5), i.geom FROM issues AS i ORDER BY i.road_code, i.id ; END;]]> >'tolerance')::real, 2.0); -- Distance used by the triggers to split an edge by a node, and to reuse an existing node node_tolerance real = 0.50; -- Maximum distance between two connected edges connected_tolerance real = 0.001; BEGIN RETURN QUERY WITH -- Start and end points of the edges ends AS ( SELECT e.id, e.road_code, e.geom AS edge_geom, 'start'::text AS side, e.start_node AS node_id, ST_StartPoint(e.geom) AS point, ST_EndPoint(e.geom) AS opposite_point FROM road_graph.edges AS e WHERE _road_codes IS NULL OR e.road_code = ANY(_road_codes) UNION ALL SELECT e.id, e.road_code, e.geom AS edge_geom, 'end'::text AS side, e.end_node AS node_id, ST_EndPoint(e.geom) AS point, ST_StartPoint(e.geom) AS opposite_point FROM road_graph.edges AS e WHERE _road_codes IS NULL OR e.road_code = ANY(_road_codes) ), -- Free ends: no other edge is connected to them free_ends AS ( SELECT f.* FROM ends AS f WHERE NOT EXISTS ( SELECT 1 FROM road_graph.edges AS o WHERE o.id != f.id AND ST_DWithin(o.geom, f.point, connected_tolerance) ) ), -- Closest other edge less than the tolerance from each free end. Are ignored: -- * the edges connected to the opposite end of the edge, for example its next edge if it is very short, -- * the edges crossed by the edge near its free end: the edge goes beyond the other edge, -- the crossing is found by the check G01 gaps AS ( SELECT DISTINCT ON (f.id, f.side) f.*, o.id AS other_id, o.road_code AS other_road_code, ST_Distance(o.geom, f.point) AS distance, ST_ClosestPoint(o.geom, f.point) AS closest_point, ST_StartPoint(o.geom) AS other_start, ST_EndPoint(o.geom) AS other_end FROM free_ends AS f JOIN road_graph.edges AS o ON o.id != f.id AND ST_DWithin(o.geom, f.point, tolerance) AND NOT ST_DWithin(o.geom, f.opposite_point, connected_tolerance) AND NOT ( ST_Intersects(o.geom, f.edge_geom) AND ST_DWithin(ST_Intersection(o.geom, f.edge_geom), f.point, tolerance) ) ORDER BY f.id, f.side, ST_Distance(o.geom, f.point) ), -- Point to join: the closest point of the other edge, -- or its start or end point if it is closer than the distance used by the triggers to split it targets AS ( SELECT g.*, CASE WHEN ST_DWithin(g.closest_point, g.other_start, node_tolerance) AND ST_Distance(g.closest_point, g.other_start) <= ST_Distance(g.closest_point, g.other_end) THEN g.other_start WHEN ST_DWithin(g.closest_point, g.other_end, node_tolerance) THEN g.other_end ELSE g.closest_point END AS target FROM gaps AS g ), -- Two free ends close to each other: keep only one issue issues AS ( SELECT t.* FROM targets AS t WHERE NOT EXISTS ( SELECT 1 FROM free_ends AS f WHERE f.id = t.other_id AND ST_Equals(f.point, t.target) AND f.id < t.id AND ST_DWithin(f.point, t.point, tolerance) ) ) SELECT 'G02'::text, 'Edge ending near another edge without being connected'::text, 'error'::text, i.road_code, ARRAY[i.id, i.other_id], CASE WHEN i.node_id IS NULL THEN NULL ELSE ARRAY[i.node_id] END, NULL::integer[], jsonb_build_object( 'road_codes', jsonb_build_array(i.road_code, i.other_road_code), 'distance', round(ST_Distance(i.point, i.target)::numeric, 2), -- The free end joins the other edge in its middle, or at its start or end point 'join_type', CASE WHEN ST_Equals(i.target, i.closest_point) THEN 'edge' ELSE 'edge_end' END ), 'extend_edge'::text, jsonb_build_object( 'edge_id', i.id, 'side', i.side, 'point', ST_AsEWKT(i.point), 'target', ST_AsEWKT(i.target) ), i.point, ST_MakeLine(i.point, i.target) FROM issues AS i ORDER BY i.road_code, i.id, i.side ; END;]]> item AS item_ids FROM items, "road_graph".editing_sessions WHERE status = 'edited' AND id = _editing_session_id ), item_cols AS ( SELECT item, string_agg(c.column_name, ', ' ORDER BY ordinal_position) AS cols FROM items, information_schema.columns c WHERE table_schema = 'road_graph' AND table_name = item AND c.column_name != 'id' GROUP BY item ), queries AS ( SELECT item, "key"::integer AS id, "value" AS op FROM ids, jsonb_each_text(item_ids) ) SELECT concat( CASE WHEN op = 'I' THEN 'INSERT INTO' WHEN op = 'U' THEN 'UPDATE' WHEN op = 'D' THEN 'DELETE FROM' END, ' ', '"road_graph".', q.item, ' AS t ', CASE WHEN op = 'I' THEN 'SELECT * FROM road_graph_editing.' || q.item || ' AS s ' WHEN op = 'U' THEN concat( ' SET (', c.cols, ') = (', 's.', replace(c.cols, ', ', ', s.'), ') FROM road_graph_editing.', q.item, ' AS s ' ) WHEN op = 'D' THEN '' END, ' ', CASE WHEN op = 'I' THEN ' WHERE s.id = ' || id::text WHEN op = 'U' THEN ' WHERE s.id = t.id AND t.id = ' || id::text WHEN op = 'D' THEN ' WHERE t.id = ' || id::text END, CASE WHEN op = 'I' THEN ' ON CONFLICT DO NOTHING ' ELSE '' END, ';' ) AS sql FROM queries AS q, item_cols AS c WHERE q.item = c.item ; END;]]> >'edge_id')::integer ; IF edge.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The edge %s does not exist anymore', _params->>'edge_id') ); END IF; IF NOT ARRAY[edge.start_node, edge.end_node] @> ARRAY[ (_params->>'keep_node_id')::integer, (_params->>'remove_node_id')::integer ] THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The nodes of the edge %s have changed', edge.id) ); END IF; IF (SELECT count(*) FROM road_graph.edges AS e WHERE e.road_code = edge.road_code) = 1 THEN RETURN jsonb_build_object( 'status', 'error', 'message', format('The edge %s is the only edge of the road %s', edge.id, edge.road_code) ); END IF; -- An edge starting and ending at the same node, for example an edge reduced to a point -- after being cut, is only deleted IF edge.start_node = edge.end_node THEN DELETE FROM road_graph.edges AS e WHERE e.id = edge.id ; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The edge %s starting and ending at the node %s has been deleted', edge.id, edge.start_node ) ); END IF; SELECT n.* INTO keep_node FROM road_graph.nodes AS n WHERE n.id = (_params->>'keep_node_id')::integer ; remove_node_id = (_params->>'remove_node_id')::integer; -- The edges extended or moved below run along the short edge and pass near the node to remove: -- the variables prevent the triggers from splitting them at the crossings with the short edge -- and at the node to remove (see after_edge_insert_or_update) PERFORM set_config('road.graph.edge.crossing.node.creation.pending', 'yes', true); PERFORM set_config('road.graph.merge.edges.useless.node', remove_node_id::text, true); -- The edge of the same road following the short edge at the node to remove, if there is only one, -- is extended with the geometry of the short edge up to the node to keep: the geometry of the road is kept SELECT e.id INTO extended_edge_id FROM road_graph.edges AS e WHERE e.road_code = edge.road_code AND e.id != edge.id AND ( (remove_node_id = edge.end_node AND e.start_node = remove_node_id) OR (remove_node_id = edge.start_node AND e.end_node = remove_node_id) ) AND ( SELECT count(*) FROM road_graph.edges AS x WHERE x.road_code = edge.road_code AND x.id != edge.id AND remove_node_id IN (x.start_node, x.end_node) ) = 1 ; IF extended_edge_id IS NOT NULL THEN UPDATE road_graph.edges AS e SET geom = ST_RemoveRepeatedPoints( CASE WHEN remove_node_id = edge.end_node THEN ST_MakeLine(edge.geom, e.geom) ELSE ST_MakeLine(e.geom, edge.geom) END ) WHERE e.id = extended_edge_id ; END IF; -- Move the start and end points of the other edges of the node to remove to the node to keep, -- for example the edges of the other roads: the triggers use the closest node, i.e. the node to keep UPDATE road_graph.edges AS e SET geom = ST_SetPoint(e.geom, 0, keep_node.geom) WHERE e.start_node = remove_node_id AND e.id != edge.id ; UPDATE road_graph.edges AS e SET geom = ST_SetPoint(e.geom, ST_NPoints(e.geom) - 1, keep_node.geom) WHERE e.end_node = remove_node_id AND e.id != edge.id ; PERFORM set_config('road.graph.edge.crossing.node.creation.pending', 'no', true); PERFORM set_config('road.graph.merge.edges.useless.node', '-1', true); -- Delete the short edge, then the node to remove if it is not used anymore DELETE FROM road_graph.edges AS e WHERE e.id = edge.id ; DELETE FROM road_graph.nodes AS n WHERE n.id = remove_node_id AND NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE remove_node_id IN (e.start_node, e.end_node) ) ; -- Check no edge uses the node to remove anymore. -- If not, the exception cancels the changes of this fix (see fix_graph_issue) IF EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE remove_node_id IN (e.start_node, e.end_node) ) THEN RAISE EXCEPTION 'The edges of the node % could not be moved to the node %', remove_node_id, keep_node.id; END IF; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The edge %s has been deleted%s, and the edges of the node %s have been moved to the node %s', edge.id, CASE WHEN extended_edge_id IS NULL THEN '' ELSE format(' and its geometry added to the edge %s', extended_edge_id) END, remove_node_id, keep_node.id ) ); END;]]> >'point'); IF cut_point IS NULL THEN RETURN jsonb_build_object('status', 'error', 'message', 'The parameter point is missing'); END IF; -- The issue has already been fixed if no edge must be split at this point: -- no edge which can be cut passes there without starting or ending there IF NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE ST_DWithin(e.geom, cut_point, tolerance) AND NOT ST_DWithin(ST_StartPoint(e.geom), cut_point, tolerance) AND NOT ST_DWithin(ST_EndPoint(e.geom), cut_point, tolerance) AND NOT Coalesce(e.no_intersection_cutting, False) ) THEN RETURN jsonb_build_object('status', 'skipped', 'message', 'No edge to split at this point'); END IF; -- Use the existing node close to the cut_point, if any: touching it splits the edges under it SELECT n.id INTO node_id FROM road_graph.nodes AS n WHERE ST_DWithin(n.geom, cut_point, tolerance) ORDER BY n.geom <-> cut_point LIMIT 1 ; IF node_id IS NOT NULL THEN SET LOCAL road.graph.edge.update.touching.node = 'yes'; UPDATE road_graph.nodes AS n SET geom = n.geom WHERE n.id = node_id ; SET LOCAL road.graph.edge.update.touching.node = 'no'; RETURN jsonb_build_object( 'status', 'success', 'message', format('The edges have been split by the existing node %s', node_id) ); END IF; -- Create a node at the point: the triggers split the edges under it INSERT INTO road_graph.nodes (geom) VALUES (cut_point) RETURNING id INTO node_id ; RETURN jsonb_build_object( 'status', 'success', 'message', format('The edges have been split by the new node %s', node_id) ); END;]]> >'node_id')::integer ; IF node.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The node %s does not exist anymore', _params->>'node_id') ); END IF; -- Edges of the node: the edge arriving at the node and the edge leaving it. -- An edge starting and ending at the node (loop) is neither arriving nor leaving SELECT count(e.id) AS edge_count, count(DISTINCT e.road_code) AS road_code_count, count(DISTINCT Coalesce(e.no_intersection_cutting, False)) AS cutting_count, (array_agg(e.id) FILTER (WHERE x.is_arriving))[1] AS arriving_edge_id, (array_agg(e.start_node) FILTER (WHERE x.is_arriving))[1] AS start_node_id, (array_agg(e.geom) FILTER (WHERE x.is_arriving))[1] AS arriving_geom, (array_agg(e.id) FILTER (WHERE x.is_leaving))[1] AS leaving_edge_id, (array_agg(e.end_node) FILTER (WHERE x.is_leaving))[1] AS end_node_id, (array_agg(e.geom) FILTER (WHERE x.is_leaving))[1] AS leaving_geom INTO edges_data FROM road_graph.edges AS e, LATERAL ( SELECT e.end_node = node.id AND e.start_node != node.id AS is_arriving, e.start_node = node.id AND e.end_node != node.id AS is_leaving ) AS x WHERE node.id IN (e.start_node, e.end_node) ; -- Node without edge: delete it IF edges_data.edge_count = 0 THEN DELETE FROM road_graph.nodes AS n WHERE n.id = node.id ; RETURN jsonb_build_object( 'status', 'success', 'message', format('The node %s without edge has been deleted', node.id) ); END IF; -- The node may have been connected to other edges by a previous fix IF NOT ( edges_data.edge_count = 2 AND edges_data.road_code_count = 1 AND edges_data.cutting_count = 1 AND edges_data.arriving_edge_id IS NOT NULL AND edges_data.leaving_edge_id IS NOT NULL AND edges_data.start_node_id != edges_data.end_node_id ) THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The node %s is not useless anymore', node.id) ); END IF; -- The two edges must only touch each other at the node: -- an edge crossing the other one cannot be merged IF NOT ST_Touches(edges_data.arriving_geom, edges_data.leaving_geom) THEN RETURN jsonb_build_object( 'status', 'error', 'message', format( 'The edges %s and %s cross each other and cannot be merged: ' || 'fix the issues of the check G01 first', edges_data.arriving_edge_id, edges_data.leaving_edge_id ) ); END IF; -- Delete the node: the trigger before_node_delete merges the two edges into the edge with the lowest id -- An error of the triggers, for example a node still used by an edge, cancels the changes of this fix BEGIN DELETE FROM road_graph.nodes AS n WHERE n.id = node.id ; EXCEPTION WHEN foreign_key_violation THEN RAISE EXCEPTION 'The edges % and % cannot be merged: fix the issues of the checks G01 and G03 first', edges_data.arriving_edge_id, edges_data.leaving_edge_id ; END; -- Check the merged edge goes from the start node of the arriving edge to the end node of the leaving edge. -- If not, for example if the merged edge has been split by the triggers at a crossing or near another node, -- the exception cancels the changes of this fix (see fix_graph_issue) SELECT e.id, e.start_node, e.end_node, count(*) OVER () AS edge_count INTO kept_edge FROM road_graph.edges AS e WHERE e.id IN (edges_data.arriving_edge_id, edges_data.leaving_edge_id) LIMIT 1 ; IF kept_edge.id IS NULL OR kept_edge.edge_count != 1 OR kept_edge.start_node IS DISTINCT FROM edges_data.start_node_id OR kept_edge.end_node IS DISTINCT FROM edges_data.end_node_id THEN -- The message is split in string constants on separate lines, which are concatenated RAISE EXCEPTION 'The edges % and % cannot be merged without other changes of the graph, ' 'for example because they cross other edges or pass near other nodes: ' 'fix the issues of the checks G01 and G03 first', edges_data.arriving_edge_id, edges_data.leaving_edge_id ; END IF; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The node %s has been deleted, and the edges %s and %s have been merged into the edge %s', node.id, edges_data.arriving_edge_id, edges_data.leaving_edge_id, kept_edge.id ) ); END;]]> >'point'); target = ST_GeomFromEWKT(_params->>'target'); IF free_end IS NULL OR target IS NULL OR _params->>'side' NOT IN ('start', 'end') THEN RETURN jsonb_build_object( 'status', 'error', 'message', 'The parameters edge_id, side, point and target are needed' ); END IF; -- The edge must still end at the free end SELECT e.* INTO edge FROM road_graph.edges AS e WHERE e.id = (_params->>'edge_id')::integer AND ST_DWithin( CASE WHEN _params->>'side' = 'start' THEN ST_StartPoint(e.geom) ELSE ST_EndPoint(e.geom) END, free_end, connected_tolerance ) ; IF edge.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The edge %s does not end anymore at the given point', _params->>'edge_id') ); END IF; -- The free end may have been connected by a previous fix IF EXISTS ( SELECT 1 FROM road_graph.edges AS o WHERE o.id != edge.id AND ST_DWithin(o.geom, free_end, connected_tolerance) ) THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The edge %s is already connected at this point', edge.id) ); END IF; free_node_id = CASE WHEN _params->>'side' = 'start' THEN edge.start_node ELSE edge.end_node END; -- Existing node at the point to join, for example the start or end point of the other edge SELECT n.id, n.geom INTO target_node FROM road_graph.nodes AS n WHERE ST_DWithin(n.geom, target, precision_tolerance) AND n.id IS DISTINCT FROM free_node_id ORDER BY n.geom <-> target, n.id LIMIT 1 ; IF target_node.id IS NOT NULL THEN -- Connect the free end to this node. If the free end is less than 50 cm from it, -- the free end is replaced by the node: a point added would be too close to the node of the free end, -- which would be used again by the triggers UPDATE road_graph.edges AS e SET geom = CASE WHEN ST_DWithin(free_end, target_node.geom, node_tolerance) AND _params->>'side' = 'start' THEN ST_SetPoint(e.geom, 0, target_node.geom) WHEN ST_DWithin(free_end, target_node.geom, node_tolerance) THEN ST_SetPoint(e.geom, ST_NPoints(e.geom) - 1, target_node.geom) WHEN _params->>'side' = 'start' THEN ST_AddPoint(e.geom, target_node.geom, 0) ELSE ST_AddPoint(e.geom, target_node.geom) END WHERE e.id = edge.id ; -- Delete the node of the free end, which is not used anymore DELETE FROM road_graph.nodes AS n WHERE n.id = free_node_id AND NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE n.id IN (e.start_node, e.end_node) ) ; ELSIF ST_DWithin(free_end, target, node_tolerance) THEN -- The free end is less than 50 cm from the other edge: move the node of the free end to the point to join. -- The triggers move the free end with the node, and split the other edge at the node. -- The variables force the split even if the node does not move (the point to join is rounded to 10 cm), -- and even if the other edge must not be cut (see after_node_insert_or_update) SET LOCAL road.graph.edge.update.touching.node = 'yes'; SET LOCAL road.graph.node.edge.extremity = 'yes'; UPDATE road_graph.nodes AS n SET geom = target WHERE n.id = free_node_id ; SET LOCAL road.graph.edge.update.touching.node = 'no'; SET LOCAL road.graph.node.edge.extremity = 'no'; ELSE -- Add the point to join at the free end of the edge: -- the triggers move the node of the free end to this point, and split the other edge there UPDATE road_graph.edges AS e SET geom = CASE WHEN _params->>'side' = 'start' THEN ST_AddPoint(e.geom, target, 0) ELSE ST_AddPoint(e.geom, target) END WHERE e.id = edge.id ; END IF; -- Check the free end is now connected to another edge. -- If not, the exception cancels the changes of this fix (see fix_graph_issue) IF NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e JOIN road_graph.edges AS o ON o.id != e.id AND CASE WHEN _params->>'side' = 'start' THEN e.start_node ELSE e.end_node END IN (o.start_node, o.end_node) WHERE e.id = edge.id ) THEN RAISE EXCEPTION 'The edge % could not be connected to the other edge', edge.id; END IF; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The edge %s has been extended by %s m to the other edge', edge.id, round(ST_Distance(free_end, target)::numeric, 2) ) ); END;]]> >'point'); IF cut_point IS NULL THEN RETURN jsonb_build_object('status', 'error', 'message', 'The parameter point is missing'); END IF; -- Set no_intersection_cutting to True for the given edge, or for all the given edges, -- if they still pass by the crossing point WITH marked AS ( UPDATE road_graph.edges AS e SET no_intersection_cutting = True WHERE ST_DWithin(e.geom, cut_point, tolerance) AND NOT Coalesce(e.no_intersection_cutting, False) AND ( CASE WHEN _params ? 'edge_id' THEN e.id = (_params->>'edge_id')::integer ELSE e.id IN (SELECT jsonb_array_elements_text(_params->'edge_ids')::integer) END ) RETURNING e.id ) SELECT array_agg(m.id ORDER BY m.id) INTO marked_ids FROM marked AS m ; IF marked_ids IS NULL THEN RETURN jsonb_build_object('status', 'skipped', 'message', 'No edge to mark at this point'); END IF; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The field no_intersection_cutting has been set to True for the edges %s', array_to_string(marked_ids, ', ') ) ); END;]]> >'keep_node_id')::integer ; SELECT n.* INTO remove_node FROM road_graph.nodes AS n WHERE n.id = (_params->>'remove_node_id')::integer ; -- The node may have been merged or deleted by a previous fix IF remove_node.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The node %s does not exist anymore', _params->>'remove_node_id') ); END IF; IF keep_node.id IS NULL THEN RETURN jsonb_build_object( 'status', 'error', 'message', format('The node to keep %s does not exist anymore', _params->>'keep_node_id') ); END IF; -- The nodes must not be linked by an edge, which would be reduced to a point IF EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE (e.start_node = keep_node.id AND e.end_node = remove_node.id) OR (e.start_node = remove_node.id AND e.end_node = keep_node.id) ) THEN RETURN jsonb_build_object( 'status', 'error', 'message', format('The nodes %s and %s are linked by an edge', keep_node.id, remove_node.id) ); END IF; -- Move the start and end points of the edges of the node to remove to the node to keep: -- the triggers use the node to keep for these edges UPDATE road_graph.edges AS e SET geom = ST_SetPoint(e.geom, 0, keep_node.geom) WHERE e.start_node = remove_node.id ; UPDATE road_graph.edges AS e SET geom = ST_SetPoint(e.geom, ST_NPoints(e.geom) - 1, keep_node.geom) WHERE e.end_node = remove_node.id ; -- Delete the node to remove, which has no edge anymore DELETE FROM road_graph.nodes AS n WHERE n.id = remove_node.id AND NOT EXISTS ( SELECT 1 FROM road_graph.edges AS e WHERE remove_node.id IN (e.start_node, e.end_node) ) ; RETURN jsonb_build_object( 'status', 'success', 'message', format('The node %s has been merged into the node %s', remove_node.id, keep_node.id) ); END;]]> >'marker_id')::integer ; IF marker.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The marker %s does not exist anymore', _params->>'marker_id') ); END IF; SELECT e.* INTO edge FROM road_graph.edges AS e WHERE e.id = (_params->>'edge_id')::integer AND e.road_code = marker.road_code AND ST_DWithin(ST_StartPoint(e.geom), ST_GeomFromEWKT(_params->>'point'), 0.01) ; IF edge.id IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The edge %s does not start anymore at the given point', _params->>'edge_id') ); END IF; IF ST_DWithin(marker.geom, ST_StartPoint(edge.geom), 0.01) THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format('The marker %s is already at the start of the road', marker.id) ); END IF; -- Move the marker to the start of the edge: the triggers calculate again the references of the road UPDATE road_graph.markers AS m SET geom = ST_StartPoint(edge.geom) WHERE m.id = marker.id ; RETURN jsonb_build_object( 'status', 'success', 'message', format( 'The marker %s of the road %s has been moved by %s m to the start of the road', marker.code, marker.road_code, round(ST_Distance(marker.geom, ST_StartPoint(edge.geom))::numeric, 2) ) ); END;]]> 'edge_ids') AS x ; IF issue_edge_ids IS NULL THEN RETURN jsonb_build_object( 'status', 'error', 'message', 'The parameter edge_ids is needed' ); END IF; -- Options of the check G05 set by the administrator, to find the reversed edges like the check SELECT g.default_options INTO check_options FROM "road_graph".glossary_graph_check AS g WHERE g.code = 'G05' ; -- The edges still in the opposite direction of their road: -- the edges may have been reversed, split or merged by a previous fix SELECT array_agg(DISTINCT e.road_code) INTO road_codes FROM road_graph.edges AS e WHERE e.id = ANY(issue_edge_ids) ; SELECT array_agg(DISTINCT x ORDER BY x) INTO reversed_ids FROM road_graph.check_graph_reversed_edges(road_codes, check_options) AS i, unnest(i.edge_ids) AS x WHERE x = ANY(issue_edge_ids) ; IF reversed_ids IS NULL THEN RETURN jsonb_build_object( 'status', 'skipped', 'message', format( 'The edges %s are not in the opposite direction of their road anymore', array_to_string(issue_edge_ids, ', ') ) ); END IF; -- Reverse the edges one by one: the triggers swap the start and end nodes of each edge, -- and calculate again its previous and next edges and the references of its road FOREACH reversed_edge_id IN ARRAY reversed_ids LOOP UPDATE road_graph.edges AS e SET geom = ST_Reverse(e.geom) WHERE e.id = reversed_edge_id ; END LOOP; -- Check the edges are now in the direction of their road. -- If not, the exception cancels the changes of this fix (see fix_graph_issue) IF EXISTS ( SELECT 1 FROM road_graph.check_graph_reversed_edges(road_codes, check_options) AS i WHERE i.edge_ids && reversed_ids ) THEN RAISE EXCEPTION 'The edges % are still in the opposite direction of their road after being reversed', array_to_string(reversed_ids, ', '); END IF; RETURN jsonb_build_object( 'status', 'success', 'message', format('The edges %s have been reversed', array_to_string(reversed_ids, ', ')) ); END;]]> marker.geom AS distance, -- BEWARE: it can be a point e.g if the marker is at the end of the edge -- it why we do not cast with -- It could also be an empty geometry ST_LineSubstring( e.geom, ST_LineLocatePoint(e.geom, marker.geom), 1 ) AS sub_geom FROM road_graph.edges AS e WHERE True -- same road AND e.road_code = _road_code ORDER BY distance, start_cumulative LIMIT 1 ) SELECT INTO closest_edge e.id, e.road_code, e.start_node, e.end_node, e.start_marker, e.start_abscissa, e.start_cumulative, e.end_marker, e.end_abscissa, e.end_cumulative, e.geom, e.previous_edge_id, e.next_edge_id, distance, (CASE WHEN GeometryType(sub_geom) = 'POINT' THEN ST_MakeLine(sub_geom, sub_geom)::geometry(LINESTRING, 2154) ELSE CASE -- If the geometry is empty, we take the closest edge end point WHEN ST_IsEmpty(sub_geom) THEN ST_MakeLine(ST_EndPoint(e.geom), ST_EndPoint(e.geom))::geometry(LINESTRING, 2154) ELSE sub_geom END END)::geometry(LINESTRING, 2154) AS sub_geom FROM get_closest_edge AS e ; IF closest_edge IS NULL THEN IF raise_notice = 'yes' THEN RAISE NOTICE 'Closest edge from given marker % cannot be found for road %', _marker_code, _road_code; END IF; RETURN NULL; END IF; IF raise_notice = 'yes' THEN RAISE NOTICE 'Closest edge found: id = %', closest_edge.id; RAISE NOTICE 'Closest edge found: sub_geom = %', ST_AsText(closest_edge.sub_geom); END IF; -- Merge all linestrings for the given road -- after the closest edge -- ordered by edge order (we use the next_edge_id to calculate the edges order) WITH ordered_ids AS ( SELECT * FROM road_graph.get_ordered_edges(_road_code, closest_edge.id, 'downstream') ) SELECT INTO merged_downstream_edges -- ids -- array_agg(e.id ORDER BY o.edge_order) AS ids, -- geometries of downstream edges ST_Collect(e.geom ORDER BY o.edge_order) AS geom FROM road_graph.edges AS e INNER JOIN ordered_ids AS o ON e.id = o.id WHERE True -- same road code AND e.road_code = _road_code -- not the closest edge AND e.id != closest_edge.id -- downstream compared to closest edge AND e.start_marker >= closest_edge.end_marker AND e.start_cumulative >= closest_edge.end_cumulative GROUP BY e.road_code ; -- Build the linestring IF merged_downstream_edges IS NULL THEN -- There is no edges after the closest edge -- We just need to use the splitted closest edge geometry -- RAISE NOTICE 'Downstream edges cannot be found for given marker %', _marker_code; downstream_road = ST_Multi(closest_edge.sub_geom); ELSE -- There are some edges after the closest edge -- We must merge the splitted closest edge and the downstream edges SELECT INTO downstream_road --ST_LineMerge( -- ST_LineMerge cannot be used as it creates a valid multilinestring -- but will not preserve order of the parts. -- So the final geometry could be reversed when adding measure in the next step -- even with the new "directed" parameter which concerns segments and not parts ST_CollectionExtract( -- even if ST_Collect collects 2 multiilnestrings -- we must extract only 2 to be able to get a multilinestring as result ST_Collect(geom ORDER BY merge_order), --extract lines 2 ) AS geom FROM ( SELECT 1::int AS merge_order, -- We need to transform sub geom into multilinestring -- to have only multilinestrings in the collected result ST_Multi(closest_edge.sub_geom) AS geom UNION ALL SELECT 2::int AS merge_order, merged_downstream_edges AS geom ) AS foo ; END IF; IF raise_notice = 'yes' THEN RAISE NOTICE 'Merge downstream edges %', ST_AsText(downstream_road); RAISE NOTICE 'downstream_road length = %, _abscissa = %', ST_Length(downstream_road), _abscissa; END IF; -- Return full JSONb with parameters and computed geometry RETURN jsonb_build_object( 'road_code', _road_code, 'marker_code', _marker_code, 'abscissa', _abscissa, 'closest_marker_abscissa', marker.abscissa, 'downstream_road', downstream_road ); END;]]> >'marker_code')::text::integer, 'start_abscissa', (start_references->>'abscissa')::text::real, 'start_cumulative', (start_references->>'cumulative')::text::real, 'end_marker', (end_references->>'marker_code')::text::integer, 'end_abscissa', (end_references->>'abscissa')::text::real, 'end_cumulative', (end_references->>'cumulative')::text::real ) ; END;]]> i.item, '{}'::jsonb)) AS l WHERE es.id = _editing_session_id ), -- Only the edges whose geometry or road has changed. -- The edges only updated by the calculation of their references are not taken into account modified_edges AS ( SELECT l.id FROM logged AS l LEFT JOIN "road_graph".edges AS o ON o.id = l.id LEFT JOIN road_graph_editing.edges AS n ON n.id = l.id AND l.op != 'D' WHERE l.item = 'edges' AND ( o.id IS NULL OR n.id IS NULL OR o.road_code != n.road_code OR NOT ST_Equals(o.geom, n.geom) ) ), -- The modified edges before (production schema) and after (editing schema) the modifications all_edges AS ( SELECT 'old' AS version, e.road_code, e.geom, e.start_marker, e.start_abscissa, e.end_marker FROM "road_graph".edges AS e JOIN modified_edges AS m ON m.id = e.id UNION ALL SELECT 'new' AS version, e.road_code, e.geom, e.start_marker, e.start_abscissa, e.end_marker FROM road_graph_editing.edges AS e JOIN modified_edges AS m ON m.id = e.id ), -- The modified markers before and after the modifications all_markers AS ( SELECT m.road_code, m.code FROM "road_graph".markers AS m JOIN logged AS l ON l.item = 'markers' AND l.id = m.id UNION SELECT m.road_code, m.code FROM road_graph_editing.markers AS m JOIN logged AS l ON l.item = 'markers' AND l.id = m.id AND l.op != 'D' ), roads AS ( SELECT DISTINCT a.road_code FROM all_edges AS a UNION SELECT DISTINCT m.road_code FROM all_markers AS m ), edges_impacts AS ( SELECT r.road_code, ( SELECT ST_Union(a.geom) FROM all_edges AS a WHERE a.road_code = r.road_code AND a.version = 'old' ) AS old_geom, ( SELECT ST_Union(a.geom) FROM all_edges AS a WHERE a.road_code = r.road_code AND a.version = 'new' ) AS new_geom, ( SELECT Coalesce(sum(ST_Length(a.geom)), 0) FROM all_edges AS a WHERE a.road_code = r.road_code AND a.version = 'old' ) AS old_length, ( SELECT Coalesce(sum(ST_Length(a.geom)), 0) FROM all_edges AS a WHERE a.road_code = r.road_code AND a.version = 'new' ) AS new_length, -- First modified point: the least start references of the modified edges ( SELECT jsonb_build_array(a.start_marker, a.start_abscissa) FROM all_edges AS a WHERE a.road_code = r.road_code ORDER BY a.start_marker, a.start_abscissa LIMIT 1 ) AS start_reference, ( SELECT max(a.end_marker) FROM all_edges AS a WHERE a.road_code = r.road_code ) AS end_marker_code, -- The references are not calculated for some edges, for example the roundabouts ( SELECT bool_or(a.start_marker IS NULL OR a.start_abscissa IS NULL OR a.end_marker IS NULL) FROM all_edges AS a WHERE a.road_code = r.road_code ) AS null_references FROM roads AS r ), markers_impacts AS ( -- For each modified marker: its code and the code of the previous marker SELECT m.road_code, jsonb_agg( jsonb_build_array( Coalesce( ( SELECT max(p.code) FROM ( SELECT x.code FROM "road_graph".markers AS x WHERE x.road_code = m.road_code AND x.code < m.code UNION ALL SELECT x.code FROM road_graph_editing.markers AS x WHERE x.road_code = m.road_code AND x.code < m.code ) AS p ), -1 ), m.code ) ) AS marker_ranges FROM all_markers AS m GROUP BY m.road_code ) SELECT jsonb_agg( jsonb_build_object( 'road_code', e.road_code, 'whole_road', Coalesce(e.null_references, false), -- The geometry of the road has not changed when the edges have only been split 'geometry_changed', ( (e.old_geom IS NOT NULL OR e.new_geom IS NOT NULL) AND NOT Coalesce( abs(e.old_length - e.new_length) < 0.01 AND ST_HausdorffDistance(e.old_geom, e.new_geom) < 0.1, false ) ), 'start_marker_code', e.start_reference->0, 'start_abscissa', e.start_reference->1, 'end_marker_code', e.end_marker_code, 'near_geom', encode(ST_AsEWKB(ST_Collect(ARRAY[e.old_geom, e.new_geom])), 'hex'), 'marker_ranges', Coalesce(m.marker_ranges, '[]'::jsonb) ) ) FROM edges_impacts AS e LEFT JOIN markers_impacts AS m ON m.road_code = e.road_code ;]]> % + % cannot be calculated: %', _road_code, _start_marker_code, _start_abscissa, _end_marker_code, _end_abscissa, SQLERRM ; RETURN NULL; END;]]> = (i.start_marker_code, i.start_abscissa) AND (%6$s OR %1$s <= i.end_marker_code) ) OR EXISTS ( SELECT 1 FROM jsonb_array_elements(i.marker_ranges) AS r WHERE %1$s <= (r->>1)::integer AND %3$s >= (r->>0)::integer ) ) ) $SQL$, start_marker_field, start_abscissa_field, end_marker_field, end_abscissa_field, _geometry_column, CASE WHEN has_cumulative THEN 'TRUE' ELSE 'FALSE' END ); END;]]> _point, n.id LIMIT 1 ; is_created = False; IF node_id IS NOT NULL THEN RETURN NEXT; RETURN; END IF; -- Create the missing node if asked IF _create THEN -- Declare that the node is the extremity of an edge: -- the edges under it will be split, even if their field no_intersection_cutting is True -- (for example a new access road arriving in the middle of a highway edge) -- The variable is used by the trigger function after_node_insert_or_update SET LOCAL road.graph.node.edge.extremity = 'yes'; WITH new_node AS ( INSERT INTO road_graph.nodes (geom) VALUES (_point) ON CONFLICT ON CONSTRAINT nodes_geom_key DO NOTHING RETURNING id ) SELECT new_node.id FROM new_node INTO node_id ; SET LOCAL road.graph.node.edge.extremity = 'no'; node_geom = _point; is_created = True; END IF; RETURN NEXT; RETURN; END;]]> _point AS distance -- since it can lead to some PostGIS errors if used in the ORDER BY -- such as "ERROR: index returned tuples in wrong order" ST_Distance(e.geom, _point) AS distance FROM road_graph.edges AS e INNER JOIN ordered_ids AS o ON e.id = o.id -- Limit search for the given road code WHERE e.road_code = _road_code -- Limit search to 50m AND ST_DWithin(e.geom, _point, 50) -- we must also order by edge_order, start_cumulative -- in case the point catches multiple edges (start and end points) ORDER BY distance, o.edge_order, e.start_cumulative -- Get only the closest edge, with the least edge_order -- start cumulative LIMIT 1 ; ELSE SELECT INTO closest_edge e.*, -- Calculate the distance between the edge and the point -- Do not use e.geom <-> _point AS distance -- since it can lead to some PostGIS errors if used in the ORDER BY -- such as "ERROR: index returned tuples in wrong order" ST_Distance(e.geom, _point) AS distance FROM road_graph.edges AS e -- LIMIT search without road_code TO 50m WHERE ST_DWithin(e.geom, _point, 50) ORDER BY distance -- Get only the closest edge LIMIT 1 ; END IF; IF closest_edge IS NULL THEN IF raise_notice = 'debug' THEN RAISE NOTICE 'CLOSEST_EDGE is NULL'; END IF; RETURN NULL; END IF; IF raise_notice = 'debug' THEN RAISE NOTICE 'CLOSEST_EDGE %', to_json(closest_edge); END IF; -- Get road_code found_road_code = closest_edge.road_code; WITH get_previous_marker AS ( SELECT * FROM road_graph.get_road_previous_marker_from_point( found_road_code, _point, _use_cache ) ), marker_data AS ( SELECT -- marker data m.*, -- Multilinestring from the marker to the point ST_Difference( -- linestring between the marker and _point m.road_linestring_from_marker_to_point, -- multilinestring made with connectors between edges end points and start points m.closing_multilinestring, -- grid size to avoid rounding issues 0.01 ) AS upstream_road_from_marker, -- Multilinestring from the road start to the point ST_Difference( -- linestring between the road start and the point m.road_linestring_from_start_to_point, -- multilinestring made with connectors between edges end points and start points m.closing_multilinestring, -- grid size to avoid rounding issues 0.01 ) AS upstream_road_from_start FROM get_previous_marker AS m ) SELECT INTO closest_edge_marker m.* FROM marker_data AS m ; IF raise_notice = 'debug' THEN RAISE NOTICE 'CLOSEST_EDGE_MARKER %', to_json(closest_edge_marker); RAISE NOTICE '-'; END IF; -- Calculate values to return based on the generated geometries -- If the marker is the next edge start marker, because the point -- was not on an edge but between two unconnected edges, -- we should take information from this edge. found_marker_code = closest_edge_marker.code; found_abscissa = CASE WHEN closest_edge_marker.is_next_edge_start_marker IS NOT TRUE THEN ST_Length(closest_edge_marker.upstream_road_from_marker) + closest_edge_marker.abscissa ELSE closest_edge_marker.abscissa END ; found_cumulative = CASE WHEN closest_edge_marker.is_next_edge_start_marker IS NOT TRUE THEN Coalesce(ST_Length(closest_edge_marker.upstream_road_from_start), 0) ELSE closest_edge_marker.cumulative END ; found_offset = CASE WHEN closest_edge_marker.is_next_edge_start_marker IS NOT TRUE THEN closest_edge.distance ELSE 0.0 END ; found_side = ( CASE WHEN ST_Contains( ST_Buffer( closest_edge.geom, closest_edge.distance +1, 'side=left' ), _point ) THEN 'left' ELSE 'right' END ); -- Build the JSON to return RETURN json_build_object( 'road_code', found_road_code, 'marker_code', found_marker_code, 'abscissa', round(found_abscissa::numeric, 2), 'cumulative', round(found_cumulative::numeric, 2), 'offset', round(found_offset::numeric, 2), 'side', found_side ); END;]]> = ST_Length(_downstream_road) THEN ST_Length(_downstream_road) ELSE "_abscissa" - _closest_marker_abscissa END, -- JSON helper to choose side and offset ((json_build_object('left', +1, 'right', -1))->>("_side"))::integer * "_offset" ) ) , 1 ), 0.01 )::geometry(POINT, 2154) ; -- Return full JSONb with parameters and computed geometry RETURN jsonb_build_object( 'road_code', _road_code, 'marker_code', _marker_code, 'abscissa', _abscissa, 'offset', _offset, 'side', _side, 'closest_marker_abscissa', _closest_marker_abscissa, 'geom', result_point ); END;]]> marker is m1 p1 -> marker is m2b (virtual marker with a non-null abscissa) p2 -> marker is m3 p3 -> marker is m4, since it is the start marker of the first next edge and p3 is not on a real previous edge. The function also returns: * the simple linestring (no gaps) made by merging all edges linestrings from the marker to the point * the simple linestring (no gaps) made by merging all edges linestrings from the start to the point * the multilinestring made by collecting all connectors between end and start points, which will help to remove them from linestrings to create the definitive geometry (with gaps) * if the found marker is the start marker of the next edge (for p3-like cases when the point is between two edges)]]> >(m.id::text))::float8, _road_info.point_location ) AS road_linestring_from_marker_to_point, -- Linestring (with no gaps) between the start of the road and the point ST_LineSubstring( _road_info.simple_linestring, 0, _road_info.point_location ) AS road_linestring_from_start_to_point, -- MultiLinestring of the linestrings generated to close the gaps between edges -- used in other functions to remove them from the road linestring parts _road_info.closing_multilinestring, -- MultiLinestring of the edges (with gaps between edges) _road_info.edges_multilinestring, -- road simple linestring : the single linestring (with no gaps) made by merging all edges linestrings and closing linestrings _road_info.simple_linestring AS road_simple_linestring, False AS is_next_edge_start_marker, NULL::real as cumulative FROM road_graph.markers AS m WHERE True -- Only the markers of the road AND m.road_code = _road_code AND (_road_info.marker_locations->>(m.id::text))::float8 <= _road_info.point_location ORDER BY (_road_info.marker_locations->>(m.id::text))::float8 DESC LIMIT 1 ; -- RAISE NOTICE '% = %' , 'get previous marker from cache', 1000 * (extract(epoch FROM clock_timestamp() - _start_ts)) - _overhead; ELSE -- Use plain query to avoid creating temporary tables WITH -- get road ordered edges (use previous and next edge ids) ordered_edges AS ( SELECT DISTINCT o.id, o.road_code, o.edge_order, o.geom FROM road_graph.get_ordered_edges(_road_code, -1, 'downstream') AS o ), touching_edges AS ( -- For each edge, add a line at the end of it -- from the previous edge (lag) end point -- to the edge start_point SELECT o.id, o.road_code, o.edge_order, -- closing lines between last end point and edge start point ST_MakeLine( Coalesce( ST_EndPoint(LAG(o.geom) OVER(ORDER BY edge_order)), ST_StartPoint(o.geom) ), ST_StartPoint(o.geom) ) AS closing_line, -- Merge closing lines and edge geometry ST_LineMerge(ST_Union( ST_MakeLine( Coalesce( ST_EndPoint(LAG(o.geom) OVER(ORDER BY edge_order)), ST_StartPoint(o.geom) ), ST_StartPoint(o.geom) ), o.geom )) AS geom, o.geom AS edge_geom FROM ordered_edges AS o ORDER BY o.edge_order ), road_line AS ( SELECT a.*, -- Calculate the location of the given point against this generated linestring ST_LineLocatePoint(a.geom, _point) AS point_location FROM ( -- Create a single linestring by merging all edge augmented linestrings SELECT max(t.road_code) AS road_code, ST_MakeLine(t.geom ORDER BY t.edge_order) AS geom, ST_CollectionExtract( ST_MakeValid( ST_Multi(ST_Collect(t.closing_line ORDER BY t.edge_order)) ), 2 ) AS closing_multilinestring, ST_CollectionExtract( ST_MakeValid( ST_Multi(ST_Collect(t.edge_geom ORDER BY t.edge_order)) ), 2 ) AS edges_multilinestring FROM touching_edges AS t ) AS a ), marker_position AS ( -- For each marker of the road, get its fractionnal location -- against the single merged linestring -- and all other needed columns values SELECT m.id, m.road_code, m.code, m.abscissa, m.geom, ST_LineLocatePoint(l.geom, m.geom) AS marker_location, l.geom AS road_simple_linestring FROM road_line as l, road_graph.markers AS m WHERE True AND m.road_code = _road_code -- No need to add filter 'AND m.road_code = l.road_code' since there is only one linestring -- No need to order data either -- ORDER BY m.code, m.abscissa ) -- Get the previous marker -- which is the one with the location just before the _point location -- We also compute the linestring from the marker to the end of the road -- since we can use it to simplify the calcution of the reference from the point SELECT INTO _previous_marker m.id, m.road_code, m.code, m.abscissa, m.geom, -- Linestring (with no gaps) between the marker and the point ST_LineSubstring( l.geom, m.marker_location, point_location ) AS road_linestring_from_marker_to_point, -- Linestring (with no gaps) between the start of the road and the point ST_LineSubstring( l.geom, 0, point_location ) AS road_linestring_from_start_to_point, -- MultiLinestring of the linestrings generated to close the gaps between edges -- used in other functions to remove them from the road linestring parts l.closing_multilinestring, -- MultiLinestring of the edges (with gaps between edges) l.edges_multilinestring, -- road simple linestring : the single linestring (with no gaps) made by merging all edges linestrings and closing linestrings l.geom AS road_simple_linestring, False AS is_next_edge_start_marker, NULL::real as cumulative FROM marker_position AS m, road_line AS l WHERE True AND m.marker_location <= l.point_location ORDER BY m.marker_location DESC LIMIT 1 ; -- RAISE NOTICE '% = %' , 'get road info without cache', 1000 * (extract(epoch FROM clock_timestamp() - _start_ts)) - _overhead; END IF; -- Check if the _point is between 2 real edges or close to the edges _point_is_between_edges = CASE WHEN ST_Distance( _point, _previous_marker.road_simple_linestring ) != ST_Distance( _point, _previous_marker.edges_multilinestring ) THEN True ELSE False END ; -- RAISE NOTICE '% = %' , 'check point between edges', 1000 * (extract(epoch FROM clock_timestamp() - _start_ts)) - _overhead; -- RAISE NOTICE '_point_is_between_edges: %', _point_is_between_edges; -- If the point is between two edges (floating in the air), -- we get the closest edge start, and replace the return references if needed -- |---ID:5-----(4)---------| there is a gap X |(7+60)----ID:10-----------| -- 4+180 7+60 -- the point X should have the references 7+60 if it is close enough to the edge ID 10 IF _point_is_between_edges IS TRUE THEN -- Get the closest edge (tolerance 5m) SELECT INTO _closest_edge_at_5m e.id, e.start_marker, e.start_abscissa, e.start_cumulative, _point <-> ST_StartPoint(e.geom) AS distance, ST_StartPoint(e.geom) AS geom FROM road_graph.edges AS e WHERE e.road_code = _road_code AND ST_DWithin(ST_StartPoint(e.geom), _point, 5) ORDER BY distance LIMIT 1 ; IF _closest_edge_at_5m.id IS NOT NULL AND Coalesce(_closest_edge_at_5m.start_marker * 10000 + _closest_edge_at_5m.start_abscissa, 0.0) > Coalesce(_previous_marker.code * 10000 + _previous_marker.abscissa, 0.0) THEN -- RAISE NOTICE 'We should use the next edge start_marker instead of the previous marker code'; _previous_marker.id := _closest_edge_at_5m.id; _previous_marker.code := Coalesce(_closest_edge_at_5m.start_marker, 0); _previous_marker.abscissa := Coalesce(_closest_edge_at_5m.start_abscissa, 0.0); _previous_marker.geom := _closest_edge_at_5m.geom; -- Linestring (with no gaps) between the marker and the point -- In this case, we adapt and return the same geometry as the one between the start and the point _previous_marker.road_linestring_from_marker_to_point := _previous_marker.road_linestring_from_start_to_point; -- Declare we have not taken the previous marker, but the start marker of the first next edge _previous_marker.is_next_edge_start_marker = True; -- we also need the start_cumulative _previous_marker.cumulative = _closest_edge_at_5m.start_cumulative; END IF; END IF; -- Return the previous marker data RETURN QUERY SELECT _previous_marker.id, _previous_marker.road_code, _previous_marker.code, _previous_marker.abscissa, _previous_marker.geom, _previous_marker.road_linestring_from_marker_to_point, _previous_marker.road_linestring_from_start_to_point, _previous_marker.closing_multilinestring, _previous_marker.is_next_edge_start_marker, _previous_marker.cumulative ; END;]]> 0 ), -- Group the consecutive segments on the same road groups AS ( SELECT sr.*, sr.segment_index - row_number() OVER (PARTITION BY sr.part, sr.road_code ORDER BY sr.segment_index) AS group_id FROM segment_roads AS sr ), road_lines AS ( SELECT row_number() OVER (ORDER BY min(g.segment_index))::integer AS road_order, g.road_code, ST_LineMerge(ST_MakeLine(g.geom ORDER BY g.segment_index)) AS geom FROM groups AS g GROUP BY g.part, g.road_code, g.group_id ), road_references AS ( SELECT rl.*, -- For roundabouts, the start and end points of the closed road are the same: -- use points 1cm inside the line to avoid any ambiguity -- and correct the references afterwards with this shift CASE WHEN ro.road_type = 'roundabout' AND ST_Length(rl.geom) > 0.1 THEN 0.01 ELSE 0 END AS shift, road_graph.get_reference_from_point( CASE WHEN ro.road_type = 'roundabout' AND ST_Length(rl.geom) > 0.1 THEN ST_LineInterpolatePoint(rl.geom, 0.01 / ST_Length(rl.geom)) ELSE ST_StartPoint(rl.geom) END, rl.road_code, False ) AS start_ref, road_graph.get_reference_from_point( CASE WHEN ro.road_type = 'roundabout' AND ST_Length(rl.geom) > 0.1 THEN ST_LineInterpolatePoint(rl.geom, 1 - 0.01 / ST_Length(rl.geom)) ELSE ST_EndPoint(rl.geom) END, rl.road_code, False ) AS end_ref FROM road_lines AS rl LEFT JOIN road_graph.roads AS ro ON ro.road_code = rl.road_code ), road_directions AS ( SELECT rr.*, CASE WHEN (rr.end_ref->>'cumulative')::numeric >= (rr.start_ref->>'cumulative')::numeric THEN 1 ELSE -1 END AS sign FROM road_references AS rr ) SELECT rd.road_order, rd.road_code, (rd.start_ref->>'marker_code')::integer, ((rd.start_ref->>'abscissa')::numeric - rd.sign * rd.shift)::real, ((rd.start_ref->>'cumulative')::numeric - rd.sign * rd.shift)::real, (rd.end_ref->>'marker_code')::integer, ((rd.end_ref->>'abscissa')::numeric + rd.sign * rd.shift)::real, ((rd.end_ref->>'cumulative')::numeric + rd.sign * rd.shift)::real, CASE WHEN rd.sign = 1 THEN 'downstream' ELSE 'upstream' END, round(ST_Length(rd.geom)::numeric, 2)::real, rd.geom::geometry(LineString, 2154) FROM road_directions AS rd ORDER BY rd.road_order ; END;]]> _road_edges_min_max_values.max_code THEN _end_marker_code = _road_edges_min_max_values.max_code; -- Add 2000m to the end abscissa to go to the end of the line _end_marker_abscissa = _road_edges_min_max_values.max_abscissa; END IF; IF _end_marker_code = _road_edges_min_max_values.max_code AND _end_marker_abscissa > _road_edges_min_max_values.max_abscissa THEN _end_marker_abscissa = _road_edges_min_max_values.max_abscissa; END IF; -- For roundabouts, fix issues preventing from calculating the geometry -- Useful when processing external data before integrating them into the managed objects IF ( SELECT (r.road_type = 'roundabout') AS test FROM road_graph.roads AS r WHERE r.road_code = _road_code ) IS TRUE THEN -- We set the start and end marker code to 0 (the only marker code for roundabouts) _start_marker_code = 0; _end_marker_code = 0; -- If the start point has an abscissa of 0+1M or less than 1 meter, we set it to 0 IF _start_marker_abscissa <= 1.0 THEN _start_marker_abscissa = 0.0; END IF; -- If the start point has an abscissa less than 1 meter from the max cumulative, we set it to 0 IF abs(_road_edges_min_max_values.max_abscissa - _start_marker_abscissa) <= 1.0 THEN _start_marker_abscissa = 0.0; END IF; -- If the end point has an abscissa lower than 1 meter, we set it to the max cumulative IF _end_marker_abscissa <= 1.0 THEN _end_marker_abscissa = _road_edges_min_max_values.max_abscissa; END IF; -- If the end point has an abscissa close to the max cumulative, we set it to the max cumulative IF abs(_road_edges_min_max_values.max_abscissa - _end_marker_abscissa) <= 1 THEN _end_marker_abscissa = _road_edges_min_max_values.max_abscissa; END IF; END IF; -- Tests IF _start_marker_code > _end_marker_code THEN RAISE EXCEPTION 'The start marker code (%) cannot be greater than the end marker code (%)', _start_marker_code, _end_marker_code ; END IF; IF _start_marker_code = _end_marker_code AND _start_marker_abscissa >= _end_marker_abscissa THEN RAISE EXCEPTION 'The start abscissa (%) cannot be equal or greater than the end abscissa (%) when the start and end marker have the same code (%)', _start_marker_abscissa, _end_marker_abscissa, _start_marker_code ; END IF; -- Add default values for offset and side if they are NULL _offset = Coalesce(_offset, 0.0); _side = Coalesce(_side, 'right'); -- Then we may add the first edge (touching the start point) IF _from_first_edge_start IS TRUE THEN -- We get the edges closest to the given start marker -- (its start point is before the marker) SELECT e.start_marker, e.start_abscissa INTO _start_marker_code, _start_marker_abscissa FROM road_graph.edges AS e WHERE e.road_code = _road_code AND e.start_marker::int * 10000 + e.start_abscissa <= _start_marker_code * 10000 + _start_marker_abscissa ORDER BY e.start_cumulative DESC LIMIT 1 ; END IF; -- Then we may add the last edge (touching the end point) IF _to_last_edge_end IS TRUE THEN -- We get the edges closest to the given end marker -- (its end is after the marker) SELECT e.end_marker, e.end_abscissa INTO _end_marker_code, _end_marker_abscissa FROM road_graph.edges AS e WHERE e.road_code = _road_code AND e.end_marker * 10000 + e.end_abscissa >= _end_marker_code * 10000 + _end_marker_abscissa ORDER BY e.end_cumulative ASC LIMIT 1 ; END IF; -- Get downstream start MULTILINESTRING from start marker to end of the road SELECT closest_marker_abscissa, downstream_road FROM jsonb_to_record( road_graph.get_downstream_multilinestring_from_reference( _road_code, _start_marker_code, _start_marker_abscissa ) ) AS ( road_code text, marker_code integer, abscissa real, closest_marker_abscissa real, downstream_road geometry(MULTILINESTRING, 2154) ) INTO _start_multilinestring ; IF raise_notice = 'yes' THEN RAISE NOTICE '_start_multilinestring closest_marker_abscissa %', _start_multilinestring.closest_marker_abscissa; RAISE NOTICE '_start_multilinestring downstream_road %', ST_AsText(_start_multilinestring.downstream_road); END IF; _start_closest_marker_abscissa = _start_multilinestring.closest_marker_abscissa; _start_downstream_road = _start_multilinestring.downstream_road; -- Add measure to the downstream road part from 0 to length _start_downstream_road_m = ST_AddMeasure(_start_downstream_road, 0, ST_Length(_start_downstream_road)); IF raise_notice = 'yes' THEN RAISE NOTICE '_start_downstream_road_m %', ST_AsText(_start_downstream_road_m); END IF; -- Get downstream end MULTILINESTRING from end marker to end of the road SELECT closest_marker_abscissa, downstream_road FROM jsonb_to_record( road_graph.get_downstream_multilinestring_from_reference( _road_code, _end_marker_code, _end_marker_abscissa ) ) AS ( road_code text, marker_code integer, abscissa real, closest_marker_abscissa real, downstream_road geometry(MULTILINESTRING, 2154) ) INTO _end_multilinestring ; IF raise_notice = 'yes' THEN RAISE NOTICE '_end_multilinestring closest_marker_abscissa %', _end_multilinestring.closest_marker_abscissa; RAISE NOTICE '_end_multilinestring downstream_road %', ST_AsText(_end_multilinestring.downstream_road); END IF; _end_closest_marker_abscissa = _end_multilinestring.closest_marker_abscissa; _end_downstream_road = _end_multilinestring.downstream_road; -- Add measure to the downstream road part from 0 to length _end_downstream_road_m = ST_AddMeasure(_end_downstream_road, 0, ST_Length(_end_downstream_road)); IF raise_notice = 'yes' THEN RAISE NOTICE '_end_downstream_road_m %', ST_AsText(_end_downstream_road_m); END IF; -- Create substring lines -- start _start_substring = ST_CollectionExtract( ST_Force2D(ST_LocateBetween( _start_downstream_road_m, CASE WHEN _start_marker_abscissa - _start_closest_marker_abscissa >= ST_Length(_start_downstream_road) THEN ST_Length(_start_downstream_road) ELSE _start_marker_abscissa - _start_closest_marker_abscissa END, ST_Length(_start_downstream_road) )) , 2 ) ; IF raise_notice = 'yes' THEN RAISE NOTICE '_start_substring %', ST_AsText(_start_substring); END IF; -- end _end_substring = ST_CollectionExtract( ST_Force2D(ST_LocateBetween( _end_downstream_road_m, CASE WHEN _end_marker_abscissa - _end_closest_marker_abscissa >= ST_Length(_end_downstream_road) THEN ST_Length(_end_downstream_road) ELSE _end_marker_abscissa - _end_closest_marker_abscissa END, ST_Length(_end_downstream_road) )) , 2 ) ; IF raise_notice = 'yes' THEN RAISE NOTICE '_end_substring %', ST_AsText(_end_substring); END IF; -- Return multilinestring between given references -- First we do the difference between start and end substrings to remove the common part between them result_multilinestring := ST_Difference( -- start _start_substring, --end _end_substring, -- we must use a tolerance to be sure the 2 lines are considered as equal -- when they are very close but not exactly equal due to digitizing or calculation precision issues 0.01 ) ; IF raise_notice = 'yes' THEN RAISE NOTICE 'result_multilinestring ST_Difference %', ST_AsText(result_multilinestring); END IF; -- Then we must merge the touching lines to avoid the offset curve function to produce gaps or crossing lines result_multilinestring_a = ST_LineMerge( result_multilinestring -- , True ); IF raise_notice = 'yes' THEN RAISE NOTICE 'result_multilinestring ST_LineMerge %', ST_AsText(result_multilinestring); END IF; -- Then we apply the offset curve on the result -- BEWARE: The ST_OffsetCurve does not respect the initial linestring node order ! -- The function road_graph.reorder_multilinestring_parts will do the job result_multilinestring_b := ST_Multi( ST_LineMerge( ST_OffsetCurve( ST_Multi( result_multilinestring_a )::geometry(MULTILINESTRING, 2154), -- The offset value is multiplied by +1 or -1 depending on the side (right or left) ((json_build_object('left', +1, 'right', -1))->>("_side"))::integer * "_offset" ) -- , -- True ) ) ; -- Reorder the multilinestring parts if needed -- This method also ensure that the lines are orientations follows the references result_multilinestring_b := road_graph.reorder_multilinestring_parts( result_multilinestring_b, _road_code ); -- Raise notice with the final result -- We reduce the precision, but not too much result_multilinestring = ST_ReducePrecision( result_multilinestring_b, 0.01 ); IF raise_notice = 'yes' THEN RAISE NOTICE 'result_multilinestring %', ST_AsText(result_multilinestring); END IF; -- Return full JSONb with parameters and computed geometry RETURN jsonb_build_object( 'road_code', _road_code, 'start_marker_code', _start_marker_code, 'start_marker_abscissa', _start_marker_abscissa, 'end_marker_code', _end_marker_code, 'end_marker_abscissa', _end_marker_abscissa, 'offset', _offset, 'side', _side, 'start_geom', _start_substring, 'end_geom', _end_substring, 'geom', result_multilinestring ); END;]]> 0 AND run_edges[s] = point_record.id THEN run_last_m[s] = point_record.measure; run_min_m[s] = least(run_min_m[s], point_record.measure); run_max_m[s] = greatest(run_max_m[s], point_record.measure); EXIT; END IF; -- Remove the previous run if it is a spur IF s > 1 AND run_start_nodes[s] != run_end_nodes[s] THEN node_in = CASE WHEN run_end_nodes[s - 1] IN (run_start_nodes[s], run_end_nodes[s]) THEN run_end_nodes[s - 1] WHEN run_start_nodes[s - 1] IN (run_start_nodes[s], run_end_nodes[s]) THEN run_start_nodes[s - 1] END; node_out = CASE WHEN point_record.start_node IN (run_start_nodes[s], run_end_nodes[s]) THEN point_record.start_node WHEN point_record.end_node IN (run_start_nodes[s], run_end_nodes[s]) THEN point_record.end_node END; IF node_in = node_out THEN node_m = CASE WHEN node_in = run_start_nodes[s] THEN 0 ELSE 1 END; IF greatest(abs(run_min_m[s] - node_m), abs(run_max_m[s] - node_m)) * run_lengths[s] <= _max_distance THEN s = s - 1; -- Test again with the new previous run CONTINUE; END IF; END IF; END IF; -- New run s = s + 1; run_edges[s] = point_record.id; run_start_nodes[s] = point_record.start_node; run_end_nodes[s] = point_record.end_node; run_lengths[s] = point_record.edge_length; run_first_m[s] = point_record.measure; run_last_m[s] = point_record.measure; run_min_m[s] = point_record.measure; run_max_m[s] = point_record.measure; EXIT; END LOOP; END LOOP; -- 3/ Fill the gaps between two consecutive edges which are not connected, -- for example when a short road (roundabout) has been skipped. -- We search the shortest path of maximum 5 edges between the two edges FOR i IN 1..s LOOP f = f + 1; final_edges[f] = run_edges[i]; final_start_nodes[f] = run_start_nodes[i]; final_end_nodes[f] = run_end_nodes[i]; final_first_m[f] = run_first_m[i]; final_last_m[f] = run_last_m[i]; CONTINUE WHEN i = s; CONTINUE WHEN run_start_nodes[i] IN (run_start_nodes[i + 1], run_end_nodes[i + 1]) OR run_end_nodes[i] IN (run_start_nodes[i + 1], run_end_nodes[i + 1]) ; WITH RECURSIVE edge_a AS ( SELECT e.*, ST_LineInterpolatePoint(e.geom, run_last_m[i]) AS point FROM road_graph.edges AS e WHERE e.id = run_edges[i] ), edge_b AS ( SELECT e.*, ST_LineInterpolatePoint(e.geom, run_first_m[i + 1]) AS point FROM road_graph.edges AS e WHERE e.id = run_edges[i + 1] ), local_edges AS ( SELECT e.id, e.start_node, e.end_node, ST_Length(e.geom) AS edge_length FROM road_graph.edges AS e, edge_a AS a, edge_b AS b WHERE ST_DWithin(e.geom, ST_MakeLine(a.point, b.point), 2 * _max_distance) AND e.id NOT IN (a.id, b.id) ), start_nodes AS ( SELECT a.start_node AS node, run_last_m[i] * ST_Length(a.geom) AS cost FROM edge_a AS a UNION ALL SELECT a.end_node, (1 - run_last_m[i]) * ST_Length(a.geom) FROM edge_a AS a ), end_nodes AS ( SELECT b.start_node AS node, run_first_m[i + 1] * ST_Length(b.geom) AS cost FROM edge_b AS b UNION ALL SELECT b.end_node, (1 - run_first_m[i + 1]) * ST_Length(b.geom) FROM edge_b AS b ), paths AS ( SELECT sn.node, ARRAY[]::integer[] AS edges, ARRAY[sn.node] AS nodes, sn.cost, 0 AS depth FROM start_nodes AS sn UNION ALL SELECT CASE WHEN l.start_node = pa.node THEN l.end_node ELSE l.start_node END, pa.edges || l.id, pa.nodes || CASE WHEN l.start_node = pa.node THEN l.end_node ELSE l.start_node END, pa.cost + l.edge_length, pa.depth + 1 FROM paths AS pa INNER JOIN local_edges AS l ON pa.node IN (l.start_node, l.end_node) WHERE pa.depth < 5 AND NOT l.id = ANY(pa.edges) ) SELECT INTO bridge pa.edges, pa.nodes FROM paths AS pa INNER JOIN end_nodes AS en ON en.node = pa.node WHERE pa.depth > 0 ORDER BY pa.cost + en.cost, pa.depth LIMIT 1 ; CONTINUE WHEN bridge.edges IS NULL; IF raise_notice = 'debug' THEN RAISE NOTICE 'get_snapped_line_from_track - gap between edges % and % filled with edges %', run_edges[i], run_edges[i + 1], bridge.edges ; END IF; FOR j IN 1..array_length(bridge.edges, 1) LOOP SELECT INTO bridge_edge e.id, e.start_node, e.end_node FROM road_graph.edges AS e WHERE e.id = bridge.edges[j] ; f = f + 1; final_edges[f] = bridge_edge.id; final_start_nodes[f] = bridge_edge.start_node; final_end_nodes[f] = bridge_edge.end_node; final_first_m[f] = CASE WHEN bridge_edge.start_node = bridge_edge.end_node THEN 0 WHEN bridge.nodes[j] = bridge_edge.start_node THEN 0 ELSE 1 END; final_last_m[f] = 1 - final_first_m[f]; END LOOP; END LOOP; -- 4/ Build the line from the edges geometries -- Each edge is used from the node connecting it to the previous edge -- (or from the first snapped point) to the node connecting it to the next edge -- (or to the last snapped point). -- If two consecutive edges are not connected, a new part is created. FOR i IN 1..f LOOP node_in = NULL; node_out = NULL; IF i > 1 THEN node_in = CASE WHEN final_start_nodes[i] IN (final_start_nodes[i - 1], final_end_nodes[i - 1]) THEN final_start_nodes[i] WHEN final_end_nodes[i] IN (final_start_nodes[i - 1], final_end_nodes[i - 1]) THEN final_end_nodes[i] END; END IF; IF i < f THEN node_out = CASE WHEN final_end_nodes[i] IN (final_start_nodes[i + 1], final_end_nodes[i + 1]) THEN final_end_nodes[i] WHEN final_start_nodes[i] IN (final_start_nodes[i + 1], final_end_nodes[i + 1]) THEN final_start_nodes[i] END; END IF; -- A closed edge (roundabout) is entered by its start and left by its end entry_m = CASE WHEN node_in IS NULL THEN final_first_m[i] WHEN final_start_nodes[i] = final_end_nodes[i] THEN 0 WHEN node_in = final_start_nodes[i] THEN 0 ELSE 1 END; exit_m = CASE WHEN node_out IS NULL THEN final_last_m[i] WHEN final_start_nodes[i] = final_end_nodes[i] THEN 1 WHEN node_out = final_start_nodes[i] THEN 0 ELSE 1 END; -- New part if the edge is not connected to the previous one IF i > 1 AND node_in IS NULL AND array_length(pieces, 1) > 0 THEN parts = parts || ST_MakeLine(pieces); pieces = '{}'; END IF; CONTINUE WHEN entry_m = exit_m; SELECT INTO edge_geom e.geom FROM road_graph.edges AS e WHERE e.id = final_edges[i] ; pieces = pieces || CASE WHEN entry_m < exit_m THEN ST_LineSubstring(edge_geom, entry_m, exit_m) ELSE ST_Reverse(ST_LineSubstring(edge_geom, exit_m, entry_m)) END; END LOOP; IF array_length(pieces, 1) > 0 THEN parts = parts || ST_MakeLine(pieces); END IF; IF array_length(parts, 1) IS NULL THEN RETURN NULL; END IF; RETURN ST_Multi(ST_RemoveRepeatedPoints(ST_Collect(parts), 0.001)); END;]]> item AS item_ids FROM items, "road_graph".editing_sessions WHERE status = 'edited' AND id = _editing_session_id ), queries AS ( SELECT item, "key"::integer AS id, "value" AS op FROM ids, jsonb_each_text(item_ids) ), objects_ids AS ( SELECT item, array_agg(id) AS o_ids FROM queries GROUP BY item ), codes AS ( SELECT DISTINCT e.road_code FROM road_graph_editing.edges AS e, objects_ids AS o WHERE o.item = 'edges' AND e.id = ANY(o.o_ids) UNION SELECT DISTINCT m.road_code FROM road_graph_editing.markers AS m, objects_ids AS o WHERE o.item = 'markers' AND m.id = ANY(o.o_ids) ) SELECT array_agg(DISTINCT road_code) AS road_codes FROM codes ; END;]]> 0 THEN RETURN json_build_object( 'status', 'error', 'message', 'Some values of the field "road_type" are not road or roundabout', 'data', json_build_object( 'number', wrong_road_type.nb, 'details', wrong_road_type.road_types ), 'roads_count', roads_count, 'edges_count', edges_count, 'nodes_count', nodes_count, 'markers_count', markers_zero_count + markers_count ); END IF; -- road_class SELECT INTO wrong_road_class count(*) AS nb, string_agg(DISTINCT e.road_class, ', ' ORDER BY e.road_class) AS road_classes FROM temp_edges AS e WHERE e.road_class NOT IN ( SELECT "code" FROM road_graph.glossary_road_class ) ; IF wrong_road_class.nb > 0 THEN RETURN json_build_object( 'status', 'error', 'message', 'Some values of the field "road_class" are not present in the table "glossary_road_class"', 'data', json_build_object( 'number', wrong_road_class.nb, 'details', wrong_road_class.road_classes ), 'roads_count', roads_count, 'edges_count', edges_count, 'nodes_count', nodes_count, 'markers_count', markers_zero_count + markers_count ); END IF; -- Temporary nodes CREATE TEMPORARY TABLE temp_nodes ON COMMIT DROP AS ( WITH union_start_end AS ( SELECT id AS start_of, NULL AS end_of, start_point AS geom FROM temp_edges UNION ALL SELECT NULL AS start_of, id AS end_of, end_point AS geom FROM temp_edges ), distinct_nodes AS ( SELECT json_agg(DISTINCT start_of) FILTER (WHERE start_of IS NOT NULL) AS start_of, json_agg(DISTINCT end_of) FILTER (WHERE end_of IS NOT NULL) AS end_of, geom FROM union_start_end GROUP BY geom ) SELECT * FROM distinct_nodes ) ; CREATE INDEX ON temp_nodes USING GIST (geom); -- Disable topology triggers SELECT set_config('road.graph.disable.trigger', '1'::text, true) INTO _set_config; SELECT road_graph.toggle_foreign_key_constraints(FALSE) INTO _toggle_triggers; -- Insert nodes RAISE NOTICE 'insert nodes'; INSERT INTO road_graph.nodes AS n (created_at, updated_at, geom) SELECT now()::timestamp(0) without time zone, now()::timestamp(0) without time zone, geom FROM temp_nodes ON CONFLICT DO NOTHING ; GET DIAGNOSTICS nodes_count = ROW_COUNT; -- Insert roads RAISE NOTICE 'insert roads'; INSERT INTO road_graph.roads ( road_code, road_type, road_class, road_class_code, is_active, road_topic, is_access_road, created_at, updated_at ) SELECT DISTINCT road_code, road_type, road_class, road_class_code, is_active, road_topic, is_access_road, now()::timestamp(0) without time zone, now()::timestamp(0) without time zone FROM temp_edges ON CONFLICT DO NOTHING ; GET DIAGNOSTICS roads_count = ROW_COUNT; -- Insert edges RAISE NOTICE 'insert edges'; INSERT INTO road_graph.edges ( id, id_source, road_code, start_node, end_node, previous_edge_id, next_edge_id, geom, created_at, updated_at ) SELECT e.id, e.id_source, e.road_code, ns.id, ne.id, e.previous_edge_id, e.next_edge_id, e.geom, now()::timestamp(0) without time zone, now()::timestamp(0) without time zone FROM temp_edges AS e LEFT JOIN road_graph.nodes AS ns -- = is faster than ST_Equals ON ns.geom = e.start_point LEFT JOIN road_graph.nodes AS ne ON ne.geom = e.end_point ON CONFLICT DO NOTHING ; GET DIAGNOSTICS edges_count = ROW_COUNT; DROP TABLE IF EXISTS temp_nodes; DROP TABLE IF EXISTS temp_edges; -- Insert markers from source data RAISE NOTICE 'insert markers from source'; sql_text = format( $SQL$ INSERT INTO road_graph.markers ( id_source, road_code, code, abscissa, is_virtual, geom, created_at, updated_at ) SELECT id_source, road_code, code, abscissa, is_virtual, ST_ReducePrecision(geom, 0.10) AS geom, now()::timestamp(0) without time zone, now()::timestamp(0) without time zone FROM %I.%I -- Only import markers if their road_code is referenced in road_graph.roads -- WHERE road_code IN ( -- SELECT road_code FROM road_graph.roads -- ) ON CONFLICT DO NOTHING ; $SQL$, _source_schema, _source_markers_table ); EXECUTE sql_text; GET DIAGNOSTICS markers_count = ROW_COUNT; -- Insert markers automatic markers at the start of the first edge -- Only if there is no other marker nearby (for example with a given abscissa) RAISE NOTICE 'insert markers zero'; WITH zero AS ( SELECT e.road_code, 0, 0, True, ST_StartPoint(e.geom), now()::timestamp(0) without time zone, now()::timestamp(0) without time zone FROM road_graph.edges AS e LEFT JOIN road_graph.markers AS m ON e.road_code = m.road_code AND ST_DWithin(ST_StartPoint(e.geom), m.geom, 1) WHERE TRUE -- No previous edge : this means it is the start of the road AND e.previous_edge_id IS NULL -- No corresponding marker within the given distance AND m.id IS NULL ) INSERT INTO road_graph.markers ( road_code, code, abscissa, is_virtual, geom, created_at, updated_at ) SELECT * FROM zero ON CONFLICT DO NOTHING ; GET DIAGNOSTICS markers_zero_count = ROW_COUNT; -- Set the serial values RAISE NOTICE 'set serials'; SELECT INTO _set_val_result setval( pg_get_serial_sequence('road_graph.edges', 'id'), (SELECT max(id) FROM road_graph.edges) ); SELECT INTO _set_val_result setval( pg_get_serial_sequence('road_graph.nodes', 'id'), (SELECT max(id) FROM road_graph.nodes) ); SELECT INTO _set_val_result setval( pg_get_serial_sequence('road_graph.roads', 'id'), (SELECT max(id) FROM road_graph.roads) ); SELECT INTO _set_val_result setval( pg_get_serial_sequence('road_graph.markers', 'id'), (SELECT max(id) FROM road_graph.markers) ); -- Update edges references RAISE NOTICE 'update references'; WITH s AS ( SELECT e.road_code, array_agg(DISTINCT e.id) AS ids FROM road_graph.edges AS e WHERE start_marker IS NULL OR end_marker IS NULL GROUP BY road_code ), up AS ( SELECT road_code, road_graph.update_edge_references(s.road_code, s.ids) AS travail FROM s ORDER BY road_code ) SELECT count(*) FROM up INTO _set_val_result ; -- Re-enable triggers RAISE NOTICE 'triggers and config'; SELECT set_config('road.graph.disable.trigger', '0'::text, true) INTO _set_config; SELECT road_graph.toggle_foreign_key_constraints(TRUE) INTO _toggle_triggers; RETURN json_build_object( 'status', 'success', 'message', 'ok', 'data', null::json, 'roads_count', roads_count, 'edges_count', edges_count, 'nodes_count', nodes_count, 'markers_count', markers_zero_count + markers_count ); END;]]> >'road_code') FROM jsonb_array_elements(Coalesce(impacts, '[]'::jsonb)) AS i ; -- Create SQL to run for each edited data FOR sql_record IN SELECT sql_text FROM "road_graph".create_queries_from_editing_session(_editing_session_id) LOOP -- RAISE NOTICE 'SQL = %', sql_record.sql_text; EXECUTE sql_record.sql_text; END LOOP; -- Re-enable triggers SELECT set_config('road.graph.disable.trigger', '0'::text, true) INTO _set_config; SELECT road_graph.toggle_foreign_key_constraints(TRUE) INTO _toggle_triggers; -- Update the managed objects concerned by the editing session changes IF road_codes IS NOT NULL AND array_length(road_codes, 1) > 0 THEN -- Disable the trigger (to avoid calculate_managed_object_references to be executed) SELECT set_config('road.graph.disable.trigger', '1'::text, true) INTO _set_config; -- Loop for each managed_object tables FOR managed_object IN SELECT o.* FROM "road_graph".managed_objects AS o LOOP SELECT INTO updated_objects_number road_graph.update_managed_objects_on_graph_change( managed_object.schema_name, managed_object.table_name, road_codes, impacts ) ; RAISE NOTICE 'Number of updated managed objects for "%"."%": %', managed_object.schema_name, managed_object.table_name, Coalesce(updated_objects_number, 0) ; END LOOP; -- Re-enable triggers SELECT set_config('road.graph.disable.trigger', '0'::text, true) INTO _set_config; ELSE -- No object has been updated: empty the list of the objects updated by the previous merge UPDATE "road_graph".managed_objects SET ( last_updated_objects_ids, last_update ) = ( ARRAY[]::integer[], now()::timestamp(0) ); END IF; -- Truncate road_graph_editing tables TRUNCATE road_graph_editing.roads CASCADE; TRUNCATE road_graph_editing.markers CASCADE; TRUNCATE road_graph_editing.edges CASCADE; TRUNCATE road_graph_editing.nodes CASCADE; TRUNCATE road_graph_editing.editing_sessions CASCADE; -- Delete merged editing session DELETE FROM "road_graph".editing_sessions WHERE id = _editing_session_id ; -- Refresh the materialized view of the last updated managed objects REFRESH MATERIALIZED VIEW CONCURRENTLY road_graph.vm_managed_objects; RETURN True; END;]]> >geometry_column_data.geom_name), ST_GeomFromGeoJSON((to_json(feature_b))->>geometry_column_data.geom_name) ) ), feature_a.road_code ); -- Get the table columns, to update the references if the table has the references fields sql_text = format( $SQL$ SELECT array_agg(column_name::text) AS cols FROM information_schema.columns WHERE table_schema = '%1$s' AND table_name = '%2$s'; $SQL$, _schema_name, _table_name ); EXECUTE sql_text INTO table_cols ; -- References of the merged geometry, in the road direction (start before end), -- set explicitly since the feature A only kept its own references, -- and the table may have no trigger calculating them update_references_sql = ''; IF table_cols @> ARRAY['start_marker_code', 'start_abscissa', 'end_marker_code', 'end_abscissa']::text[] THEN start_references = road_graph.get_reference_from_point( ST_StartPoint(ST_GeometryN(target_geometry, 1)), Nullif(trim(feature_a.road_code), '') ); end_references = road_graph.get_reference_from_point( ST_EndPoint(ST_GeometryN(target_geometry, ST_NumGeometries(target_geometry))), Nullif(trim(feature_a.road_code), '') ); -- Invert start and end if needed IF ( (start_references->>'marker_code')::integer, (start_references->>'abscissa')::real ) > ( (end_references->>'marker_code')::integer, (end_references->>'abscissa')::real ) THEN SELECT end_references, start_references INTO start_references, end_references; END IF; update_references_sql = format( ', start_marker_code = %1$L::integer, start_abscissa = %2$L::real' ', end_marker_code = %3$L::integer, end_abscissa = %4$L::real', start_references->>'marker_code', start_references->>'abscissa', end_references->>'marker_code', end_references->>'abscissa' ); -- Cumulative distances if the table has these fields IF 'start_cumulative' = ANY(table_cols) THEN update_references_sql = concat( update_references_sql, format(', start_cumulative = %1$L::real', start_references->>'cumulative') ); END IF; IF 'end_cumulative' = ANY(table_cols) THEN update_references_sql = concat( update_references_sql, format(', end_cumulative = %1$L::real', end_references->>'cumulative') ); END IF; END IF; -- Disable the trigger updating the lines linked to the feature A: -- the merged line covers the feature B, and its other linked lines must not be modified PERFORM set_config('road.graph.disable.linked.geometries', '1', true); -- Delete the feature B and update the feature A in the same request sql_text = format( $SQL$ WITH del AS ( DELETE FROM %1$I.%2$I WHERE %3$I = %4$s RETURNING * ), up AS ( UPDATE %1$I.%2$I SET %5$I = ST_GeomFromGeoJSON('%6$s')%8$s WHERE %3$I = %7$s RETURNING * ) SELECT * FROM up $SQL$, _schema_name, _table_name, primary_key_field, _feature_id_b, geometry_column_data.geom_name, ST_AsGeoJSON(target_geometry), _feature_id_a, update_references_sql ); EXECUTE sql_text INTO update_result ; -- Re-enable the trigger updating the linked lines PERFORM set_config('road.graph.disable.linked.geometries', '0', true); RETURN json_build_object( 'status', 'success', 'message', 'The two features have been successfully merged.' ); END;]]> >'marker_code')::int AS start_marker_code, (start_refs->>'abscissa')::real AS start_abscissa, (start_refs->>'marker_code')::int * 10000 + (start_refs->>'abscissa')::real AS start_part_order, (end_refs->>'marker_code')::int AS end_marker_code, (end_refs->>'abscissa')::real AS end_abscissa, (end_refs->>'marker_code')::int * 10000 + (end_refs->>'abscissa')::real AS end_part_order FROM get_refs ) -- Reassemble the parts order by the calculated cost SELECT INTO _result_multilinestring ST_Multi( ST_Collect( -- Revert the geometry if needed CASE WHEN start_part_order > end_part_order THEN ST_Reverse(geom) ELSE geom END -- Order the parts based on the parts order ORDER BY end_part_order ) ) FROM extract_values ; EXCEPTION WHEN OTHERS THEN _result_multilinestring = _multilinestring; END; RETURN _result_multilinestring; END;]]> minimum_distance_from_linestring THEN RAISE NOTICE 'No edge found close enough to the node : Distance % m > % m ', ST_Distance(node_record.geom, edge_record.geom), minimum_distance_from_linestring ; RETURN NULL; END IF; -- Check the edge is not already cut IF node_record.id IN (edge_record.start_node, edge_record.end_node) OR ST_DWithin(node_record.geom, ST_StartPoint(edge_record.geom), 0.50) OR ST_DWithin(node_record.geom, ST_EndPoint(edge_record.geom), 0.50) THEN RAISE NOTICE 'Given edge is already cut for this node which corresponds to its start or end point' ; RETURN NULL; END IF; -- Create new geometries start_geom := ST_LineSubstring( edge_record.geom, 0, ST_LineLocatePoint(edge_record.geom, node_record.geom) ); end_geom := ST_LineSubstring( edge_record.geom, ST_LineLocatePoint(edge_record.geom, node_record.geom), 1 ); -- Check the cut point is not to close to the start or end point of the given linestring IF ST_length(start_geom) < maximum_distance_from_start_end_points OR ST_length(end_geom) < maximum_distance_from_start_end_points THEN-- Set variable to avoid infinite loops RAISE NOTICE 'Abort splitting the edge: given point too close from the edge end points ( < %m)', maximum_distance_from_start_end_points; RETURN NULL; END IF; -- Modify the initial edge : -- OA----------(O)----------OB becomes OA----------(O) -- we must get the new edge id beforehand to use it as next_edge_id -- For roundabout, do not calculate previous and next edge id -- To let the user decide -- The quoted schema name "road_graph" is not replaced by the plugin: -- the edges of the road_graph_editing schema also use the road_graph sequence id_new_object = nextval(pg_get_serial_sequence('"road_graph".edges', 'id')); -- The two parts of the split edge must not create nodes at their intersections with the other edges, -- nor be split by the existing nodes located under them: these intersections existed before the split. -- Without this, each split was propagated to the edges crossing the split edge, and so on, -- for example to all the bridges of a highway interchange. -- The intersections of the edge being drawn are managed by its own trigger (after_edge_insert_or_update). previous_crossing_node_creation_pending = road_graph.get_current_setting( 'road.graph.edge.crossing.node.creation.pending', 'no' ); PERFORM set_config('road.graph.edge.crossing.node.creation.pending', 'yes', true); -- The references of the road are calculated once at the end of this function, -- and not after the update of the edge, then after the insertion of the new edge, -- and after the update of the next edge by the cascading changes previous_ref_calc_disabled = road_graph.get_current_setting('road.graph.edge.ref.calc.disabled', 'no'); PERFORM set_config('road.graph.edge.ref.calc.disabled', 'yes', true); -- The end node of the initial edge is not used by any edge after its update, -- until the new edge is inserted: it must not be deleted by the trigger after_edge_insert_or_update. -- The variable road.graph.node.already.deleted gives the node which must not be deleted previous_node_already_deleted = road_graph.get_current_setting('road.graph.node.already.deleted', '-1'); PERFORM set_config('road.graph.node.already.deleted', edge_record.end_node::text, true); UPDATE road_graph.edges SET -- Set the geometry geom = start_geom, -- We must also set the downstream node id column end_node = node_record.id, -- next edge_id next_edge_id = CASE WHEN is_roundabout THEN NULL ELSE id_new_object END, -- end_cumulative end_cumulative = (end_cumulative - ST_Length(end_geom)) WHERE id = edge_record.id ; PERFORM set_config('road.graph.node.already.deleted', previous_node_already_deleted, true); -- Get the object fields minus the PK, upstream node & geometry column WITH fields AS ( SELECT json_object_keys(to_json(edge_record.*)) AS field ) SELECT concat ('"', string_agg(field, '", "'), '"') INTO source_fields FROM fields WHERE field NOT IN ( 'id', 'start_node', 'geom', 'previous_edge_id', 'next_edge_id', 'start_cumulative', 'uid' ) ; -- Check if the new edge geometry does not exists -- This avoid to create 2 superimposed edges -- especially for roundabouts. SELECT INTO new_edge_record e.id FROM road_graph.edges AS e WHERE -- use ST_DWithin and not ST_Intersects to use spatial indexing -- but keep a tolerance to avoid precision issues ST_DWithin(e.geom, end_geom, 1) AND ( ST_Equals(e.geom, end_geom) OR ST_Equals(e.geom, ST_ReducePrecision(end_geom, 0.10)) ) LIMIT 1 ; -- Create the new edge: -- (O)----------OB -- Get the values from the original linestring -- Only if the geometry does not exists IF new_edge_record.id IS NULL THEN sql_text = format( $$ INSERT INTO road_graph.edges ( id, %1$s, start_node, geom, previous_edge_id, next_edge_id, start_cumulative, uid ) WITH source AS ( SELECT e.*, r.road_type FROM road_graph.edges AS e JOIN road_graph.roads AS r ON r.road_code = e.road_code WHERE e.id = %2$s::integer LIMIT 1 ) SELECT %5$s::integer AS id, %1$s, %3$s::integer AS start_node, '%4$s'::geometry(LINESTRING) AS geom, CASE WHEN road_type = 'roundabout' THEN NULL ELSE %2$s::integer END AS previous_edge_id, CASE WHEN road_type = 'roundabout' THEN NULL ELSE(Nullif(%6$s, -1))::integer END AS next_edge_id, %7$s::real AS start_cumulative, uuid_generate_v4()::text FROM source LIMIT 1 RETURNING id $$, source_fields, edge_record.id, node_record.id, end_geom, id_new_object, Coalesce(edge_record.next_edge_id, -1), Coalesce(edge_record.end_cumulative, 0) ); -- Set again the variables, in case they have been reset by the cascading changes PERFORM set_config('road.graph.edge.crossing.node.creation.pending', 'yes', true); PERFORM set_config('road.graph.edge.ref.calc.disabled', 'yes', true); EXECUTE sql_text INTO id_new_object ; IF raise_notice IN ('info', 'debug') THEN RAISE NOTICE '% split_edge_by_node - node n° % %- splitting edge n° % : created edge n° %', repeat(' ', pg_trigger_depth()::integer), node_record.id, ST_AsText(node_record.geom), edge_record.id, id_new_object ; END IF; ELSE id_new_object = -1; END IF; -- Restore the variables PERFORM set_config( 'road.graph.edge.crossing.node.creation.pending', previous_crossing_node_creation_pending, true ); PERFORM set_config('road.graph.edge.ref.calc.disabled', previous_ref_calc_disabled, true); -- Calculate the references of the two parts of the split edge only. -- The geometry of the road has not changed: the references of its other edges are still right. -- The stored geometries are rounded to 10 cm by the trigger function aa_before_geometry_insert_or_update: -- the length of the road only changes by less than a millimeter, which is negligible. -- If the two parts are not as long as the split edge, the references of the whole road are calculated. -- Not for the roundabouts, like in the trigger function after_edge_insert_or_update IF previous_ref_calc_disabled = 'no' AND NOT is_roundabout THEN SELECT sum(ST_Length(e.geom)) - ST_Length(edge_record.geom) INTO split_length_difference FROM road_graph.edges AS e WHERE e.id IN (edge_record.id, id_new_object) ; IF id_new_object > 0 AND abs(split_length_difference) < 0.005 THEN PERFORM road_graph.update_edge_references( edge_record.road_code, ARRAY[edge_record.id, id_new_object] ); ELSE PERFORM road_graph.update_edge_references(edge_record.road_code); END IF; END IF; -- Return True RETURN id_new_object; END;]]> ARRAY['start_marker_code', 'start_abscissa', 'end_marker_code', 'end_abscissa']::text[], False ); -- Get feature sql_text = format( $SQL$ SELECT * FROM %1$I.%2$I WHERE %3$I = %4$s LIMIT 1 $SQL$, _schema_name, _table_name, primary_key_field, _feature_id ); EXECUTE sql_text INTO feature ; IF feature.geom IS NULL THEN RETURN json_build_object( 'status', 'error', 'message', format('No feature could be found with %L = %L ', primary_key_field, _feature_id) ); END IF; -- Check road_code IF nullif(trim(to_jsonb(feature)->>'road_code'), '') IS NULL THEN RETURN json_build_object( 'status', 'error', 'message', 'The given feature does not have a valid road code !' ); END IF; -- Prevent splitting if the point is not close enough to the given feature IF ST_Distance(feature.geom, _point) > 5 THEN RETURN json_build_object( 'status', 'error', 'message', format('The point is not close enough to the feature (distance %L > 5m)', ST_Distance(feature.geom, _point)::int) ); END IF; -- Get feature start and end point feature_start_point = CASE WHEN lower(GeometryType(feature.geom)) = 'linestring' THEN ST_StartPoint(feature.geom) -- hopefully the last part is really the end part of the multilinestring ELSE ST_StartPoint(ST_GeometryN(feature.geom, 1)) END; feature_end_point = CASE WHEN lower(GeometryType(feature.geom)) = 'linestring' THEN ST_EndPoint(feature.geom) -- hopefully the last part is really the end part of the multilinestring ELSE ST_EndPoint(ST_GeometryN(feature.geom, ST_NumGeometries(feature.geom))) END; -- Check position of the cutting point agains these start & end points closest_point = ST_ClosestPoint( feature.geom, _point ); IF ST_DWithin(closest_point, feature_start_point, 1.0) THEN RETURN json_build_object( 'status', 'error', 'message', format( 'The given point is too close to the start point of the given feature (%L m).', Round(ST_Distance(closest_point, feature_start_point)::numeric, 1) ) ); END IF; IF ST_DWithin(closest_point, feature_end_point, 1.0) THEN RETURN json_build_object( 'status', 'error', 'message', format( 'The given point is too close to the end point of the given feature (%L m).', Round(ST_Distance(closest_point, feature_end_point)::numeric, 1) ) ); END IF; -- Get the references of the closet point, start, end points start_references = road_graph.get_reference_from_point( feature_start_point, Nullif( trim(to_jsonb(feature)->>'road_code'), '' ) ); end_references = road_graph.get_reference_from_point( feature_end_point, Nullif( trim(to_jsonb(feature)->>'road_code'), '' ) ); closest_point_references = road_graph.get_reference_from_point( closest_point, Nullif( trim(to_jsonb(feature)->>'road_code'), '' ) ); -- The references of the managed lines follow the road direction (start before end), -- like in the functions update_table_references_from_geometries and get_road_substring_from_references. -- If the feature is digitized in the opposite direction of the road, -- its start and end references are swapped: the two new geometries follow the road direction is_reversed = ( (start_references->>'marker_code')::integer, (start_references->>'abscissa')::real ) > ( (end_references->>'marker_code')::integer, (end_references->>'abscissa')::real ); IF is_reversed THEN SELECT end_references, start_references INTO start_references, end_references; END IF; -- Build the new geometries, in the road direction -- geom_1: from the start references to the cut point -- geom_2: from the cut point to the end references geom_1 = ((road_graph.get_road_substring_from_references( to_jsonb(feature)->>'road_code', (start_references->>'marker_code')::integer, (start_references->>'abscissa')::real, (closest_point_references->>'marker_code')::integer, (closest_point_references->>'abscissa')::real, (start_references->>'offset')::real, start_references->>'side' ))->>'geom')::geometry(MultiLinestring, 2154); geom_2 = ((road_graph.get_road_substring_from_references( to_jsonb(feature)->>'road_code', (closest_point_references->>'marker_code')::integer, (closest_point_references->>'abscissa')::real, (end_references->>'marker_code')::integer, (end_references->>'abscissa')::real, (start_references->>'offset')::real, start_references->>'side' ))->>'geom')::geometry(MultiLinestring, 2154); -- Transform geometries into multigeometries if needed IF geometry_column_data.geom_type ILIKE 'multi%' THEN geom_1 = ST_Multi(geom_1); geom_2 = ST_Multi(geom_2); END IF; -- References of the two features, set explicitly instead of keeping the stored values, -- which could be in the opposite order or not correspond to the geometry: -- the feature goes from the start references to the cut point, -- and the new feature goes from the cut point to the end references. -- The cumulative distances are also set if the table has these fields update_references_sql = ''; insert_references_fields = ''; insert_references_values = ''; IF has_references THEN update_references_sql = format( ', start_marker_code = %1$L::integer, start_abscissa = %2$L::real' ', end_marker_code = %3$L::integer, end_abscissa = %4$L::real', start_references->>'marker_code', start_references->>'abscissa', closest_point_references->>'marker_code', closest_point_references->>'abscissa' ); insert_references_fields = ', start_marker_code, start_abscissa, end_marker_code, end_abscissa'; insert_references_values = format( ', %1$L::integer, %2$L::real, %3$L::integer, %4$L::real', closest_point_references->>'marker_code', closest_point_references->>'abscissa', end_references->>'marker_code', end_references->>'abscissa' ); IF 'start_cumulative' = ANY(table_cols) THEN update_references_sql = concat( update_references_sql, format(', start_cumulative = %1$L::real', start_references->>'cumulative') ); insert_references_fields = concat(insert_references_fields, ', start_cumulative'); insert_references_values = concat( insert_references_values, format(', %1$L::real', closest_point_references->>'cumulative') ); END IF; IF 'end_cumulative' = ANY(table_cols) THEN update_references_sql = concat( update_references_sql, format(', end_cumulative = %1$L::real', closest_point_references->>'cumulative') ); insert_references_fields = concat(insert_references_fields, ', end_cumulative'); insert_references_values = concat( insert_references_values, format(', %1$L::real', end_references->>'cumulative') ); END IF; END IF; -- Disable the trigger updating the linked lines: the line following the feature -- must not be moved to the cut point, since the new feature is inserted between them PERFORM set_config('road.graph.disable.linked.geometries', '1', true); -- Update the feature and insert the new one -- Use a try/catch to avoid doing half the job BEGIN -- Update the feature with the new geometry sql_text = format( $SQL$ WITH up AS ( UPDATE %1$I.%2$I SET %3$I = ST_GeomFromGeoJSON('%4$s')%7$s WHERE True AND %5$I = %6$s RETURNING * ) SELECT * FROM up $SQL$, _schema_name, _table_name, geometry_column_data.geom_name, ST_AsGeoJSON(geom_1), primary_key_field, (to_jsonb(feature))->>primary_key_field, update_references_sql ); EXECUTE sql_text INTO update_result ; -- Get the object fields minus the PK, geometry column, start_cumulative -- and the references, set explicitly WITH fields AS ( SELECT json_object_keys(to_json(feature.*)) AS field ) SELECT concat ('"', string_agg(field, '", "'), '"') INTO source_fields FROM fields WHERE field NOT IN ( primary_key_field, geometry_column_data.geom_name, 'start_marker', 'start_abscissa', 'start_cumulative', 'uid', 'longueur' ) AND NOT (has_references AND field IN ('start_marker_code', 'end_marker_code', 'end_abscissa', 'end_cumulative')) ; -- Create the new feature sql_text = format( $SQL$ INSERT INTO %1$I.%2$I ( -- geometry %3$I, -- fields %4$s -- start references %8$s ) WITH source AS ( SELECT s.* FROM %1$I.%2$I AS s WHERE %6$I = %7$L LIMIT 1 ) SELECT -- geometry ST_GeomFromGeoJSON('%5$s'), -- fields %4$s -- start references %9$s FROM source RETURNING * $SQL$, _schema_name, _table_name, geometry_column_data.geom_name, source_fields, ST_AsGeoJSON(geom_2), primary_key_field, (to_jsonb(feature))->>primary_key_field, insert_references_fields, insert_references_values ); EXECUTE sql_text INTO insert_result ; EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS v_sqlstate = returned_sqlstate, v_message = message_text, v_context = pg_exception_context ; -- Re-enable the trigger updating the linked lines PERFORM set_config('road.graph.disable.linked.geometries', '0', true); RETURN json_build_object( 'status', 'error', 'message', format('Error while splitting the feature: %s', v_sqlstate || ' - ' || v_message) ); END; -- Re-enable the trigger updating the linked lines PERFORM set_config('road.graph.disable.linked.geometries', '0', true); RETURN json_build_object( 'status', 'success', 'message', 'The given feature has been successfully splitted by the given point.' ); END;]]> >'road_code'), '') = '' OR new_jsonb->>'road_code' IS DISTINCT FROM old_jsonb->>'road_code' THEN RETURN NEW; END IF; -- Nothing to do if the references have not changed. -- The references of NEW must have been calculated before, for example by the trigger -- trg_calculate_managed_object_references (BEFORE trigger, run before this AFTER trigger) IF (new_jsonb->>'start_marker_code', new_jsonb->>'start_abscissa') IS NOT DISTINCT FROM (old_jsonb->>'start_marker_code', old_jsonb->>'start_abscissa') AND (new_jsonb->>'end_marker_code', new_jsonb->>'end_abscissa') IS NOT DISTINCT FROM (old_jsonb->>'end_marker_code', old_jsonb->>'end_abscissa') THEN RETURN NEW; END IF; -- Get the table primary key field SELECT a.attname INTO primary_key_field FROM pg_index AS i JOIN pg_attribute AS a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indrelid = TG_RELID AND i.indisprimary LIMIT 1 ; IF primary_key_field IS NULL THEN RAISE NOTICE 'The table "%"."%" does not have a primary key !', TG_TABLE_SCHEMA, TG_TABLE_NAME; RETURN NEW; END IF; -- Start and end points of the line before its modification old_end_points = ST_Collect( ST_StartPoint(ST_GeometryN(ST_Multi(OLD.geom), 1)), ST_EndPoint(ST_GeometryN(ST_Multi(OLD.geom), ST_NumGeometries(ST_Multi(OLD.geom)))) ); -- Disable the triggers on the updated linked lines: -- their references are set here, and they must not update their own linked lines PERFORM set_config('road.graph.disable.trigger', '1', true); PERFORM set_config('road.graph.disable.linked.geometries', '1', true); -- Loop over the other lines of the same road -- whose start or end point touched the start or end point of the line before its modification sql_text = format( $SQL$ SELECT to_jsonb(t) AS feature FROM %1$I.%2$I AS t WHERE t.%3$I::text != $1 AND t.road_code = $2 AND ST_DWithin(t.geom, $3, $4) AND ST_DWithin( ST_Collect( ST_StartPoint(ST_GeometryN(ST_Multi(t.geom), 1)), ST_EndPoint(ST_GeometryN(ST_Multi(t.geom), ST_NumGeometries(ST_Multi(t.geom)))) ), $3, $4 ) $SQL$, TG_TABLE_SCHEMA, TG_TABLE_NAME, primary_key_field ); FOR linked IN EXECUTE sql_text USING old_jsonb->>primary_key_field, new_jsonb->>'road_code', old_end_points, tolerance LOOP linked_jsonb = linked.feature; -- Current references of the linked line, in the road direction SELECT (linked_jsonb->>'start_marker_code')::integer AS marker_code, (linked_jsonb->>'start_abscissa')::real AS abscissa INTO linked_start; SELECT (linked_jsonb->>'end_marker_code')::integer AS marker_code, (linked_jsonb->>'end_abscissa')::real AS abscissa INTO linked_end; IF linked_start.marker_code IS NULL OR linked_start.abscissa IS NULL OR linked_end.marker_code IS NULL OR linked_end.abscissa IS NULL THEN CONTINUE; END IF; start_marker_code = linked_start.marker_code; start_abscissa = linked_start.abscissa; end_marker_code = linked_end.marker_code; end_abscissa = linked_end.abscissa; cumulative_sql = ''; IF (linked_start.marker_code, linked_start.abscissa) < ( (old_jsonb->>'start_marker_code')::integer, (old_jsonb->>'start_abscissa')::real ) THEN -- The linked line is upstream: it ended at the start of the line. -- Its end must follow the new start of the line IF (new_jsonb->>'start_marker_code', new_jsonb->>'start_abscissa') IS NOT DISTINCT FROM (old_jsonb->>'start_marker_code', old_jsonb->>'start_abscissa') THEN CONTINUE; END IF; end_marker_code = (new_jsonb->>'start_marker_code')::integer; end_abscissa = (new_jsonb->>'start_abscissa')::real; IF linked_jsonb ? 'end_cumulative' AND new_jsonb ? 'start_cumulative' THEN cumulative_sql = format(', end_cumulative = %L::real', new_jsonb->>'start_cumulative'); END IF; ELSIF (linked_end.marker_code, linked_end.abscissa) > ( (old_jsonb->>'end_marker_code')::integer, (old_jsonb->>'end_abscissa')::real ) THEN -- The linked line is downstream: it started at the end of the line. -- Its start must follow the new end of the line IF (new_jsonb->>'end_marker_code', new_jsonb->>'end_abscissa') IS NOT DISTINCT FROM (old_jsonb->>'end_marker_code', old_jsonb->>'end_abscissa') THEN CONTINUE; END IF; start_marker_code = (new_jsonb->>'end_marker_code')::integer; start_abscissa = (new_jsonb->>'end_abscissa')::real; IF linked_jsonb ? 'start_cumulative' AND new_jsonb ? 'end_cumulative' THEN cumulative_sql = format(', start_cumulative = %L::real', new_jsonb->>'end_cumulative'); END IF; ELSE -- The linked line overlaps the line: it is not modified CONTINUE; END IF; -- The line has been extended over the whole linked line: it cannot be calculated IF (start_marker_code, start_abscissa) >= (end_marker_code, end_abscissa) THEN RAISE NOTICE 'The linked line "%"."%" % = % is not modified: its new start references % + % are not before its new end references % + %', TG_TABLE_SCHEMA, TG_TABLE_NAME, primary_key_field, linked_jsonb->>primary_key_field, start_marker_code, start_abscissa, end_marker_code, end_abscissa ; CONTINUE; END IF; -- Build the new geometry of the linked line from its new references, -- keeping its offset and side BEGIN substring_jsonb = road_graph.get_road_substring_from_references( linked_jsonb->>'road_code', start_marker_code, start_abscissa, end_marker_code, end_abscissa, Coalesce((linked_jsonb->>'offset')::real, 0.0::real), Coalesce(linked_jsonb->>'side', 'right') ); EXCEPTION WHEN OTHERS THEN RAISE NOTICE 'The geometry of the linked line "%"."%" % = % cannot be calculated: %', TG_TABLE_SCHEMA, TG_TABLE_NAME, primary_key_field, linked_jsonb->>primary_key_field, SQLERRM ; CONTINUE; END; linked_geom = ST_GeomFromGeoJSON(substring_jsonb->>'geom'); IF linked_geom IS NULL OR ST_IsEmpty(linked_geom) THEN CONTINUE; END IF; linked_geom = ST_SetSRID(linked_geom, 2154); -- Adapt the geometry to the type of the table IF lower(managed_object.geometry_type) = 'linestring' THEN linked_geom = ST_LineMerge(linked_geom); IF GeometryType(linked_geom) != 'LINESTRING' THEN RAISE NOTICE 'The geometry of the linked line "%"."%" % = % is not a single linestring', TG_TABLE_SCHEMA, TG_TABLE_NAME, primary_key_field, linked_jsonb->>primary_key_field ; CONTINUE; END IF; ELSE linked_geom = ST_Multi(linked_geom); END IF; -- Update the geometry and the references of the linked line EXECUTE format( $SQL$ UPDATE %1$I.%2$I SET geom = $1, start_marker_code = $2, start_abscissa = $3, end_marker_code = $4, end_abscissa = $5 %4$s WHERE %3$I::text = $6 $SQL$, TG_TABLE_SCHEMA, TG_TABLE_NAME, primary_key_field, cumulative_sql ) USING linked_geom, start_marker_code, start_abscissa, end_marker_code, end_abscissa, linked_jsonb->>primary_key_field ; updated_number = updated_number + 1; END LOOP; -- Re-enable the triggers PERFORM set_config('road.graph.disable.linked.geometries', '0', true); PERFORM set_config('road.graph.disable.trigger', '0', true); IF updated_number > 0 THEN RAISE NOTICE 'Number of linked lines updated in "%"."%": %', TG_TABLE_SCHEMA, TG_TABLE_NAME, updated_number; END IF; RETURN NEW; END;]]> 'last_updated_objects_ids') = 'array' THEN updated_stats_references->'last_updated_objects_ids' ELSE '[]' END ) AS t UNION SELECT t FROM jsonb_array_elements( CASE WHEN jsonb_typeof(updated_stats_geometry->'last_updated_objects_ids') = 'array' THEN updated_stats_geometry->'last_updated_objects_ids' ELSE '[]' END ) AS t ) SELECT array_agg(t ORDER BY t) FROM a ); -- RAISE NOTICE 'merged_last_updated_objects_ids, %', merged_last_updated_objects_ids; -- RAISE NOTICE '--------------'; updated_stats = jsonb_build_object( 'nb', array_length(merged_last_updated_objects_ids, 1), 'last_updated_objects_ids', merged_last_updated_objects_ids ) ; END IF; -- Check results IF updated_stats IS NULL OR Coalesce((updated_stats->>'nb')::integer, 0) = 0 THEN RAISE NOTICE 'No object updated for %.%', _schema_name, _table_name; updated_stats = jsonb_build_object( 'nb', 0, 'last_updated_objects_ids', '[]'::jsonb ); END IF; -- Update the managed_objects table -- The list of the updated objects is emptied if no object has been updated: -- it must only contain the objects updated by the last change of the road graph EXECUTE format( $SQL$ UPDATE road_graph.managed_objects AS o SET ( last_updated_objects_ids, last_update ) = ( ARRAY[%3$s]::integer[], now()::timestamp(0) ) WHERE o.schema_name = '%1$I' AND o.table_name = '%2$I' $SQL$, _schema_name, _table_name, -- convert json array to string like 1,3,10 ( SELECT array_to_string(array_agg(j)::text[], ',') FROM jsonb_array_elements( CASE WHEN jsonb_typeof(updated_stats->'last_updated_objects_ids') = 'array' THEN updated_stats->'last_updated_objects_ids' ELSE '[]' END ) AS j ) ); -- Return the number of updated features, or NULL if no object has been updated RETURN Nullif((updated_stats->>'nb')::integer, 0); END;]]> needed_fields) THEN RAISE NOTICE 'The table "%"."%" does not contain the necessary fields to update geometries from references !', _schema_name, _table_name; RETURN NULL; END IF; -- Update geometries based on references -- and geometry type of the managed object -- We filter the objects to update based on the given road codes -- We must check if the road_graph function returns a valid geometry sql_text = format( $SQL$ WITH get_geom AS ( SELECT mo.%1$I AS id, road_graph.get_managed_object_geometry_from_references( mo.road_code::text, %9$s, %6$s, %7$s )->'geom' AS geom FROM %2$I.%3$I AS mo WHERE ( mo.road_code = ANY(string_to_array('%4$s', ',')::text[]) OR '%4$s' = '' ) AND (%8$s) ), updated_objects AS ( SELECT g.id, CASE WHEN g.geom = 'null'::jsonb THEN NULL ELSE ST_GeomFromGeoJSON(g.geom) END::geometry(%5$s, 2154) AS geom FROM get_geom AS g ), run_update AS ( UPDATE %2$I.%3$I AS mo SET geom = ST_ReducePrecision(u.geom, 0.01) FROM updated_objects AS u WHERE mo.%1$I = u.id AND u.geom IS NOT NULL AND ( mo.geom IS NULL OR NOT ST_Equals( ST_ReducePrecision(mo.geom, 0.01), ST_ReducePrecision(u.geom, 0.01) ) ) RETURNING mo.* ) SELECT count(r.*) AS nb, array_agg(r.%1$I) AS last_updated_objects_ids FROM run_update AS r $SQL$, -- 1 primary_key_field, -- 2 _schema_name, -- 3 _table_name, -- 4 : list of road codes Coalesce(array_to_string(_road_codes::text[], ','), ''), -- 5 : geometry type managed_object.geometry_type, -- Use default values for side and offset if columns does not exists or value is NULL -- else we need to cast to the expected function parameter formats -- 6 CASE WHEN 'offset' = ANY(table_cols) THEN 'Coalesce(mo."offset"::real, 0.0::real)' ELSE '0.0::real' END, -- 7 CASE WHEN 'side' = ANY(table_cols) THEN 'Coalesce(mo.side::text, ''right''::text) ' ELSE '''right''::text' END, -- 8 : filter of the impacted objects CASE WHEN _impacts IS NULL THEN 'TRUE' ELSE road_graph.get_managed_objects_impacts_filter(managed_object.geometry_type, table_cols, 'geom') END, -- used fields: we need to cast the values taken from the managed table -- The end references are NULL for the points -- 9 CASE WHEN lower(managed_object.geometry_type) = 'point' THEN 'mo.marker_code::integer, mo.abscissa::real, NULL::integer, NULL::real' ELSE 'mo.start_marker_code::integer, mo.start_abscissa::real, mo.end_marker_code::integer, mo.end_abscissa::real' END ); RAISE NOTICE 'sql = %', sql_text; -- Disable the trigger updating the linked lines: -- all the objects are calculated from their own references PERFORM set_config('road.graph.disable.linked.geometries', '1', true); EXECUTE sql_text INTO updated_stats USING _impacts; -- Re-enable the trigger updating the linked lines PERFORM set_config('road.graph.disable.linked.geometries', '0', true); RETURN to_jsonb(updated_stats); END;]]> needed_fields) THEN RAISE NOTICE 'The table "%"."%" does not contain the necessary fields to update references from geometries !', _schema_name, _table_name; RETURN NULL; END IF; -- Filter the objects which may be impacted by the modifications of the road graph, if given impacts_filter = CASE WHEN _impacts IS NULL THEN 'TRUE' ELSE road_graph.get_managed_objects_impacts_filter(managed_object.geometry_type, table_cols, geometry_column) END; -- Build the road cache for the roads of the objects to update -- It is always built again here, even if it already exists for a road, -- since the road graph could have been modified since its last build in the same transaction sql_text = format( $SQL$ SELECT array_agg(DISTINCT trim(mo.road_code)::text) FROM %1$I.%2$I AS mo WHERE Coalesce(trim(mo.road_code), '') != '' AND ( mo.road_code::text = ANY(string_to_array('%3$s', ',')::text[]) OR '%3$s' = '' ) $SQL$, _schema_name, _table_name, Coalesce(array_to_string(_road_codes::text[], ','), '') ); EXECUTE sql_text INTO cached_road_codes ; FOREACH cached_road_code IN ARRAY Coalesce(cached_road_codes, ARRAY[]::text[]) LOOP PERFORM road_graph.build_road_cached_objects(cached_road_code); END LOOP; -- Get road information -- Update references based on geometries -- and geometry type of the managed object -- We filter the objects to update based on the given road codes IF lower(managed_object.geometry_type) = 'point' THEN sql_text = format( $SQL$ WITH objects AS ( SELECT mo.%1$I AS id, trim(mo.road_code)::text AS road_code, mo.%9$I AS geom FROM %2$I.%3$I AS mo WHERE ( mo.road_code::text = ANY(string_to_array('%4$s', ',')::text[]) OR '%4$s' = '' ) AND (%10$s) ), refs AS ( SELECT o.id, road_graph.get_reference_from_point( o.geom, -- We need to pass the road code to force the calculation to keep references for this road o.road_code::text, -- NULL::text, -- Use the road cache built before TRUE ) AS ref FROM objects AS o ), run_update AS ( UPDATE %2$I.%3$I AS mo SET -- Do no change the road code if no references have been found -- for the given road (meaning the object is too far) road_code = CASE -- keep object road_code intact if it is not empty WHEN Coalesce(mo.road_code, '') != '' THEN mo.road_code ELSE r.ref->>'road_code' END, -- cumulative if present %5$s -- offset if present and if _update_offset_and_side is True %6$s -- side if present and if _update_offset_and_side is True %7$s -- marker code and abscissa put here to avoid errors with commas marker_code = (r.ref->>'marker_code')::integer, abscissa = (r.ref->>'abscissa')::real FROM refs AS r WHERE TRUE AND mo.%1$I = r.id --AND r.ref->'road_code' != 'null'::jsonb AND (%8$s) RETURNING mo.* ) SELECT count(r.*) AS nb, array_agg(r.%1$I ORDER BY r.%1$I) AS last_updated_objects_ids FROM run_update AS r $SQL$, primary_key_field, _schema_name, _table_name, Coalesce(array_to_string(_road_codes::text[], ','), ''), -- 5 / add update for cumulative if the columns exists in the target table CASE WHEN 'cumulative' = ANY(table_cols) THEN $STR$cumulative = (r.ref->>'cumulative')::real, $STR$ ELSE '' END, -- 6 / add update for offset if the columns exists in the target table CASE WHEN 'offset' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$"offset" = Coalesce((r.ref->>'offset')::real, 0.0::real), $STR$ ELSE '' END, -- 7 / add update for side if the columns exists in the target table CASE WHEN 'side' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$side = Coalesce((r.ref->>'side')::text, 'right'), $STR$ ELSE '' END, -- 8 / Detect if we need to update or not -- A difference of 1 cm of the abscissa or cumulative is ignored: calculating the geometry from the references, -- then the references from this geometry rounded to 1 cm, can give a difference of 1 cm. -- Without this tolerance, the lines of the update policy geometry were shortened by 1 cm at each update concat( $STR$ ( ( Coalesce(mo.road_code, '') != '' AND coalesce((r.ref->>'road_code'), '') = '' ) OR ( Coalesce(mo.road_code, '') = '' AND coalesce((r.ref->>'road_code'), '') != '' ) ) OR (r.ref->>'marker_code')::integer != Coalesce(mo.marker_code, -1)::integer OR abs((r.ref->>'abscissa')::real - Coalesce(mo.abscissa, -1)::real) > 0.015 $STR$, CASE WHEN 'cumulative' = ANY(table_cols) THEN $STR$ OR abs((r.ref->>'cumulative')::real - Coalesce(mo.cumulative, -1)::real) > 0.015 $STR$ ELSE '' END, CASE WHEN 'offset' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$ OR Coalesce((r.ref->>'offset')::real, 0.0::real) != Coalesce(mo.offset, 0.0)::real $STR$ ELSE '' END, CASE WHEN 'side' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$ OR Coalesce((r.ref->>'side')::text, 'right') != Coalesce(mo.side, 'right')::text $STR$ ELSE '' END ), -- 9 / geometry_column geometry_column, -- 10 / filter of the impacted objects impacts_filter ); ELSIF lower(managed_object.geometry_type) IN ('linestring', 'multilinestring') THEN sql_text = format( $SQL$ WITH objects AS ( SELECT mo.%1$I AS id, trim(mo.road_code)::text AS road_code, mo.%10$I AS geom FROM %2$I.%3$I AS mo WHERE ( mo.road_code::text = ANY(string_to_array('%4$s', ',')::text[]) OR '%4$s' = '' ) AND (%11$s) ), road_info AS ( SELECT r.road_code, r.road_type, min(e.start_marker) AS min_code, max(e.end_marker) AS max_code, min(e.start_cumulative) AS min_cumulative, max(e.end_cumulative) AS max_cumulative, min(e.start_abscissa) AS min_abscissa, max(e.end_abscissa) AS max_abscissa FROM road_graph.edges AS e JOIN road_graph.roads AS r USING (road_code) WHERE e.road_code IN ( SELECT DISTINCT o.road_code FROM objects AS o ) GROUP BY r.road_code, r.road_type ), refs AS ( SELECT o.id, o.road_code, road_graph.get_reference_from_point( -- ST_StartPoint could return NULL for a MULTILINESTRING CASE WHEN lower(GeometryType(o.geom)) = 'linestring' THEN ST_StartPoint(o.geom) -- hopefully the last part is really the end part of the multilinestring ELSE ST_StartPoint(ST_GeometryN(o.geom, 1)) END, -- We need to pass the road code to force the calculation to keep references for this road o.road_code, -- NULL::text, -- Use the road cache built before TRUE ) AS start_ref, road_graph.get_reference_from_point( -- ST_EndPoint could return NULL for a MULTILINESTRING CASE WHEN lower(GeometryType(o.geom)) = 'linestring' THEN ST_EndPoint(o.geom) -- hopefully the last part is really the end part of the multilinestring ELSE ST_EndPoint(ST_GeometryN(geom, ST_NumGeometries(geom))) END, -- We need to pass the road code to force the calculation to keep references for this road o.road_code, -- NULL::text, -- Use the road cache built before TRUE ) AS end_ref FROM objects AS o ), processed_refs AS ( SELECT r.id, r.road_code, -- start_ref CASE -- For roundabout, if the start and end values are equal -- use 0+0 for start & 0+max_cumulative for end WHEN i.road_type = 'roundabout' AND Coalesce((r.start_ref->>'abscissa')::real, 0) = Coalesce((r.end_ref->>'abscissa')::real, 0) THEN jsonb_build_object( 'road_code', r.start_ref->>'road_code', 'marker_code', 0, 'abscissa', 0.0, 'cumulative', 0.0, 'offset', r.start_ref->>'offset', 'side', r.start_ref->'side' ) -- for other roads, invert start and end if start < end WHEN Coalesce((r.start_ref->>'marker_code')::int * 10000 + (r.start_ref->>'abscissa')::real, 0) > Coalesce((r.end_ref->>'marker_code')::int * 10000 + (r.end_ref->>'abscissa')::real, 0) THEN end_ref ELSE r.start_ref END AS start_ref, -- end_ref CASE -- For roundabout, if the start and end values are equal -- use 0+0 for start & 0+max_cumulative for end WHEN i.road_type = 'roundabout' AND Coalesce((r.start_ref->>'abscissa')::real, 0) = Coalesce((r.end_ref->>'abscissa')::real, 0) THEN jsonb_build_object( 'road_code', r.end_ref->>'road_code', 'marker_code', 0, 'abscissa', i.max_abscissa, 'cumulative', i.max_cumulative, 'offset', r.end_ref->>'offset', 'side', r.end_ref->'side' ) -- for other roads, invert start and end if start < end WHEN Coalesce((r.start_ref->>'marker_code')::int * 10000 + (r.start_ref->>'abscissa')::real, 0) > Coalesce((r.end_ref->>'marker_code')::int * 10000 + (r.end_ref->>'abscissa')::real, 0) THEN start_ref ELSE r.end_ref END AS end_ref FROM refs AS r JOIN road_info AS i USING (road_code) ), run_update AS ( UPDATE %2$I.%3$I AS mo SET -- Do no change the road code if no references have been found -- for the given road (meaning the object is too far) road_code = CASE -- keep object road_code intact if it is not empty WHEN Coalesce(mo.road_code, '') != '' THEN mo.road_code ELSE r.start_ref->>'road_code' END, -- start_cumulative if present %5$s -- offset if present %6$s -- side if present %7$s -- end_cumulative if present %8$s -- marker code and abscissa put here to avoid errors with commas start_marker_code = (r.start_ref->>'marker_code')::integer, start_abscissa = (r.start_ref->>'abscissa')::real, end_marker_code = (r.end_ref->>'marker_code')::integer, end_abscissa = (r.end_ref->>'abscissa')::real FROM processed_refs AS r WHERE TRUE AND mo.%1$I = r.id -- Do not UPDATE if no changes must be made (values already are the same) AND (%9$s) RETURNING mo.* ) SELECT count(r.*) AS nb, array_agg(r.%1$I ORDER BY r.%1$I) AS last_updated_objects_ids FROM run_update AS r $SQL$, primary_key_field, _schema_name, _table_name, Coalesce(array_to_string(_road_codes::text[], ','), ''), -- 5 / add update for cumulative if the columns exists in the target table CASE WHEN 'start_cumulative' = ANY(table_cols) THEN $STR$"start_cumulative" = (r.start_ref->>'cumulative')::real, $STR$ ELSE '' END, -- 6 / add update for offset if the columns exists in the target table CASE WHEN 'offset' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$"offset" = Coalesce((r.start_ref->>'offset')::real, 0.0::real), $STR$ ELSE '' END, -- 7 / add update for side if the columns exists in the target table CASE WHEN 'side' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$"side" = Coalesce((r.start_ref->>'side')::text, 'right'::text), $STR$ ELSE '' END, -- 8 / add update for cumulative if the columns exists in the target table CASE WHEN 'end_cumulative' = ANY(table_cols) THEN $STR$"end_cumulative" = (r.end_ref->>'cumulative')::real, $STR$ ELSE '' END, -- 9 / Detect if we need to update or not -- A difference of 1 cm of the abscissa or cumulative is ignored: calculating the geometry from the references, -- then the references from this geometry rounded to 1 cm, can give a difference of 1 cm. -- Without this tolerance, the lines of the update policy geometry were shortened by 1 cm at each update concat( $STR$ ( ( Coalesce(mo.road_code, '') != '' AND coalesce((r.start_ref->>'road_code'), '') = '' ) OR ( Coalesce(mo.road_code, '') = '' AND coalesce((r.start_ref->>'road_code'), '') != '' ) ) OR (r.start_ref->>'marker_code')::integer != Coalesce(mo.start_marker_code, -1)::integer OR abs((r.start_ref->>'abscissa')::real - Coalesce(mo.start_abscissa, -1)::real) > 0.015 OR (r.end_ref->>'marker_code')::integer != Coalesce(mo.end_marker_code, -1)::integer OR abs((r.end_ref->>'abscissa')::real - Coalesce(mo.end_abscissa, -1)::real) > 0.015 $STR$, CASE WHEN 'start_cumulative' = ANY(table_cols) THEN $STR$ OR abs((r.start_ref->>'cumulative')::real - Coalesce(mo.start_cumulative, -1)::real) > 0.015 $STR$ ELSE '' END, CASE WHEN 'offset' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$ OR Coalesce((r.start_ref->>'offset')::real, 0.0::real) != Coalesce(mo.offset, 0.0)::real $STR$ ELSE '' END, CASE WHEN 'side' = ANY(table_cols) AND _update_offset_and_side IS True THEN $STR$ OR Coalesce((r.start_ref->>'side')::text, 'right') != Coalesce(mo.side, 'right')::text $STR$ ELSE '' END, CASE WHEN 'end_cumulative' = ANY(table_cols) THEN $STR$ OR abs((r.end_ref->>'cumulative')::real - Coalesce(mo.end_cumulative, -1)::real) > 0.015 $STR$ ELSE '' END ), -- 10 / geometry_column geometry_column, -- 11 / filter of the impacted objects impacts_filter ); END IF; RAISE NOTICE 'sql = %', sql_text; EXECUTE sql_text INTO updated_stats USING _impacts; RETURN to_jsonb(updated_stats); END;]]>