Create a line string from street geometry

Question

I'm currently facing some hard times trying to create a simplified line from a street geometry.
The data that I'm currently using comes from OpenStreetMap, using osm2pgsql.(Which means PostGIS, but I'm open to solutions that don't use it, or use external code, like C, JS, or whatever).

The problem: I need to create a simplified line string from given streets, however, most streets have multiple segments, such as:

In this example, the street is forked and segmented, the GeoJSON is available here.

Dumping the points of the street is useful which could be converted to a line string, however, their order is messed up, causing bizzare line formations. I could partially solve this issue ordering by lon/lat or lat/lon, but in several cases of points in the same axis or due geometry angle, it does not order them properly, and thus, does not work for all streets.

Few solutions I came up with:

• Using ST_Buffer on every segment, joining, and ST_ApproximateMedialAxis on the resulting geometry. It didn't work because some streets, even with a generous buffer have all it's segments touching each other and also ST_ApproximateMedialAxis doesn't always result in a line string (Not a function fault, it's the expected behavior).
• Ordering by LAT/LON ~ LON/LAT and creating a line from the result: Also didn't work as explained above.
• Using ST_LineMerge: Nope, in regular streets it does work, but on forked or segmented streets, it fails, as explained here.
• Iterating over points to create a line from every point nearest neighbor: Fails due the inability to find the real first and last points.

The hardest task so far is getting the farthest points from given set, to define the first and last point, getting this informations would solve the problem for me, but I'm clueless so far?

I thought about using ST_VoronoiPolygons, but I have no idea how to extract some result from that?

Answer 1

I found a solution that fits my needs:

1. Dump all points from a street geometry.
2. Collect all points, create a Voronoi Diagram from the collection, then Dump the geometries to split them in individual, orderable polygons.
3. Finally, order the polygons from their area, limit the result to 2 (2 biggest polygons, the first and last points)

This is what it looks line in the end:

SELECT *
FROM
  (SELECT (ST_DUMP(St_voronoipolygons(St_collect(dumpedpoints.geometry)))).geom AS polygons
   FROM
     (SELECT (St_dumppoints(geometry)).geom AS geometry
      FROM <your TABLE>
      WHERE <your conditions> ) AS dumpedpoints) AS voronoid
ORDER BY ST_Area(voronoid.polygons) DESC
LIMIT 2

With that in hand, I'm able to just query which point is inside the given polygons with ST_Within.

From that, having the first and last point, I wrote a JS that given a point, finds the nearest neighbor, store the data, go to the found neighbor, find his neighbor and repeat this until all points are iterated over.

/** Each point has a index inside, that's created sequentially, apart from the first OR last point, wich is always 0 so the code has the first iteration **/

const linePoints = [];
const copy = [...pointsCollection]; /** We create a iterable copy */

const points = copy.reduce(( Neighbor, Current, Index, Array ) => {

    /** Avoid iterations over nulls */
    if (Neighbor === null ) { return null } 

    /** If it's the last point, he doesn’t have any neighbors */
    if(Neighbor.index + 1 === Array.length) { return null }; 

    /** Remove itself from the points list, we do that so he doesn’t match with himself */
    pointsCollection.splice(pointsCollection.findIndex(item => item.index === Neighbor.index), 1) 

    /** Your choice function of GeoLib */
    let Nearest = nearestPoint(Neighbor, pointsCollection);
    /** Push to the final list */
    linePoints.push(Nearest);

    /** Set the Neighbor varible of the next iteration as the Neighbor found in this */
    return Nearest;

}, pointsCollection[0]); /** Set the initial value, in our case, the first or last point */

The result of that operation is a sequential array that can be used to create a line string.