Ich habe nach dem besten Weg gesucht, Linestrings nach Punkten zu schneiden.

Das Szenario ist: Viele Straßen, die Segmente müssen durch Schnittpunkte geschnitten werden, so ähnlich:

ich habe

• Tabelle der Linestrings (vollständig nach Punkten ungekürzt)

• Tabelle st_intersection points

Ich muss die unabhängigen Linestring-Segmente durch die Schnittpunkttabelle schneiden lassen.

Ich verwende PostGIS-Funktionen und habe verschiedene Ansätze gefunden, aber jeder von ihnen hat mir ein Problem bereitet.

Folgendes habe ich bereits getestet:

1

Linientabelle: 1 Zeile, st_memunion von 1200 Zeilen Punktetabelle: 1700 Zeilen (Punkte)

Was schlecht ist: braucht wirklich viel Zeit und Speicherplatz. Es können nicht mehrere Tabellen gleichzeitig erstellt werden, da der Speicher einfach nicht damit umgehen kann. Und das Ergebnis ist schmutzig und chaotisch. Anstatt mir die richtige Zeilennummer zu geben, muss ich sie später bereinigen (hier gut erklärt) Linien an Schnittpunkten teilen )

CREATE TABLE lines_with_messy_result AS (
SELECT
((ST_DUMP(ST_SPLIT(a.geom,b.ix))).geom) as geom
FROM st_union_lines a
INNER JOIN lots_of_points b
ON ST_INTERSECTS(a.geom, b.ix)
);

--then need to clean this up
create table lines_segments_cleaned as (
SELECT DISTINCT ON (ST_AsBinary(geom)) 
geom 
FROM 
lines_with_messy_result
);

Quelle dieses Weges / Ansatzes: /programming/25753348/how-do-i-divide-city-streets-by-intersection-using-postgis

2

Gleiche Linien- / Punktetabelle. Immer noch unordentliche Ergebnisse und müssen dies bereinigen. Noch viel Zeit, um die Abfrage zu beenden.

--messy table    
Create table messy_lines_segments as 
Select 
row_number() over() as id,
(st_dump(st_split(input.geom, blade.ix))).geom as geom
from st_union_lines input
inner join lots_of_points blade on st_intersects(input.geom, blade.ix);

--then cleaning the messy table
delete from messy_lines_segments a
where exists 
(
select 1 from messy_lines_segments b where a.id != b.id and st_coveredby(b.geom,a.geom)
);

Quelle dieses Weges / Ansatzes: Linien an Schnittpunkten teilen

3

Ich habe auch diese Funktion gefunden: https://github.com/Remi-C/PPPP_utilities/blob/master/postgis/rc_Split_Line_By_Points.sql

Das hat das Gute, dass es kein chaotisches Ergebnis hinterlässt, das ich dann aufräumen muss. Sie benötigen jedoch st_memunion von beiden Seiten (Linientabelle und Punktetabelle).

Es ist ein bisschen wie:

create table osm.calles_cortadas_03segmentos_sanluis as (
SELECT result.geom
FROM 
osm.calles_cortadas_01uniones_sanluis AS line, 
osm.calles_cortadas_00intersecciones_sanluis AS point,
rc_split_line_by_points(
input_line:=line.geom
,input_points:=point.ix
,tolerance:=4
) AS result
);

Aber es sind auch super lange Stunden, um die Ergebnisse zu erhalten. Und ich habe es auch mit längeren Tabellen versucht (10.000 Zeilen, 14.000 Punkte) und ich bekomme nur Speicherprobleme.

Ich habe auch Esris ArcGIS mit ebenfalls schlechten Ergebnissen ausprobiert ...

Was ist der beste Weg, um dies mit PostGIS-Geom-Funktionen zu erreichen?

Ich meine, ohne in die Topologie einzusteigen.

Oder was ist Ihre beste Empfehlung?

Das ist der Weg!

Ok, ich habe ein großartiges Feedback von Remi-C bekommen und jetzt funktioniert das wie ein Zauber:

Beste Nicht-Topologie-Lösung aller Zeiten. Sie funktioniert WIRKLICH schnell und einfach (glauben Sie mir, ich habe viele Möglichkeiten getestet, dies zu tun):

--please add this function:
https://github.com/Remi-C/PPPP_utilities/blob/master/postgis/rc_split_multi.sql

-- please create a universal sequence for unique id multipurpose
CREATE SEQUENCE select_id
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1
  CYCLE;



-- lines (non st_unioned linestrings, with gist index) : linetable
-- points (non st_unioned points, with gist index) : pointtable

-- first, lines with cuts (pointtable)
create table segment_lines_00 as (
WITH points_intersecting_lines AS( 
   SELECT lines.id AS lines_id, lines.geom AS line_geom,  ST_Collect(points.ix) AS blade
   FROM 
   linetable as lines, 
   pointtable as points
   WHERE st_dwithin(lines.geom, points.ix, 4) = true
   GROUP BY lines.id, lines.geom
)
SELECT lines_id, rc_Split_multi(line_geom, blade, 4)
FROM points_intersecting_lines
);
CREATE INDEX ON segment_lines_00 USING gist(rc_split_multi);


-- then, segments cutted by points
create table segment_lines_01 as (
select 
(ST_Dump(rc_split_multi)).geom as geom,  nextval('SELECT_id'::regclass) AS gid  from segment_lines_00
);
CREATE INDEX ON segment_lines_01 USING gist(geom);

Das ist es!.

Ich füge außerdem meine eigene Methode hinzu, ohne st_split () zu verwenden:

Für jede Linie überprüfe ich, ob es Schnittpunkte gibt.

Wenn ja, wird meine Versuchung so aussehen:

[line_id, fraction]
[1      , 0       ]
[1      , 0.3     ]
[1      , 1       ]
[2      , 0       ]
[2      , 0.88    ]
[2      , 1       ]
...

Eine Tabelle, die die Linien-ID und den Bruchteil der Linienlänge enthält, an der ein Punkt die Linie schneidet.

Dann kombiniere ich den Bruch paarweise, um die neuen Schnittlinien zu erstellen

Voraussetzung:

• Die Tabelle "Punkte" enthält die Endpunkte jeder Zeile.
• Die Punkte schneiden die Linien perfekt.

Die Abfrage:

DROP TABLE IF EXISTS temptable;

CREATE TABLE temptable as 
(
    SELECT ST_LineLocatePoint(a.geom,b.geom) as fraction,a.id, a.geom as shape
    FROM lines a, points b
    WHERE st_intersects(a.geom,b.geom)
    UNION
    SELECT 1 as fraction ,a.id, a.geom as shape -- It avoid to get an incomplete line when the original line is circular
    FROM lines a
    ORDER BY a.id, fraction -- important to keep the same order
);

ALTER TABLE temptable  ADD COLUMN gid SERIAL PRIMARY KEY;

DROP TABLE IF EXISTS LINE_SPLIT;
CREATE TABLE LINE_SPLIT AS
(
SELECT b.fend,a.*, ST_LineSubstring(a.shape,a.fstart,b.fend) as geom
FROM
    (
    SELECT *, fraction as fstart FROM temptable
    LIMIT (SELECT COUNT(*) FROM temptable)-1
    ) a,
    (
    SELECT fraction as fend,gid-1 as gid FROM temptable
    OFFSET 1
    ) b
WHERE a.gid = b.gid
AND a.fstart < b.fend
);

ALTER TABLE LINE_SPLIT DROP COLUMN IF EXISTS shape;
DROP TABLE IF EXISTS temptable;