lwgeom_node()

LWGEOM * lwgeom_node

(

const LWGEOM *

lwgeom_in

)

Definition at line 130 of file lwgeom_geos_node.c.

References LWGEOM::flags, FLAGS_GET_M, FLAGS_GET_Z, LWMLINE::geoms, LWCOLLECTION::geoms, GEOS2LWGEOM(), lwcollection_clone_deep(), lwcollection_construct_empty(), lwcollection_free(), lwcollection_reserve(), lwerror(), LWGEOM2GEOS(), lwgeom_dimension(), lwgeom_extract_unique_endpoints(), lwgeom_free(), lwgeom_geos_errmsg, lwgeom_geos_error(), lwgeom_is_collection(), lwgeom_ngeoms(), lwgeom_subgeom(), lwline_split_by_point_to(), MULTILINETYPE, LWMLINE::ngeoms, LWCOLLECTION::ngeoms, s, and LWGEOM::srid.

Referenced by lwgeom_extract_unique_endpoints(), lwt_AddLine(), ST_Node(), and test_lwgeom_node().

{
        GEOSGeometry *g1, *gn, *gm;
        LWGEOM *ep, *lines;
        LWCOLLECTION *col, *tc;
        int pn, ln, np, nl;

        if ( lwgeom_dimension(lwgeom_in) != 1 ) {
                lwerror("Noding geometries of dimension != 1 is unsupported");
                return NULL;
        }

        initGEOS(lwgeom_geos_error, lwgeom_geos_error);
        g1 = LWGEOM2GEOS(lwgeom_in, 1);
        if ( ! g1 ) {
                lwerror("LWGEOM2GEOS: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        ep = lwgeom_extract_unique_endpoints(lwgeom_in);
        if ( ! ep ) {
                GEOSGeom_destroy(g1);
                lwerror("Error extracting unique endpoints from input");
                return NULL;
        }

        gn = GEOSNode(g1);
        GEOSGeom_destroy(g1);
        if ( ! gn ) {
                lwgeom_free(ep);
                lwerror("GEOSUnaryUnion: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        gm = GEOSLineMerge(gn);
        GEOSGeom_destroy(gn);
        if ( ! gm ) {
                lwgeom_free(ep);
                lwerror("GEOSLineMerge: %s", lwgeom_geos_errmsg);
                return NULL;
        }

        lines = GEOS2LWGEOM(gm, FLAGS_GET_Z(lwgeom_in->flags));
        GEOSGeom_destroy(gm);
        if ( ! lines ) {
                lwgeom_free(ep);
                lwerror("Error during GEOS2LWGEOM");
                return NULL;
        }

        /*
         * Reintroduce endpoints from input, using split-line-by-point.
         * Note that by now we can be sure that each point splits at
         * most _one_ segment as any point shared by multiple segments
         * would already be a node. Also we can be sure that any of
         * the segments endpoints won't split any other segment.
         * We can use the above 2 assertions to early exit the loop.
         */

        col = lwcollection_construct_empty(MULTILINETYPE, lwgeom_in->srid,
                                      FLAGS_GET_Z(lwgeom_in->flags),
                                      FLAGS_GET_M(lwgeom_in->flags));

        np = lwgeom_ngeoms(ep);
        for (pn=0; pn<np; ++pn) { /* for each point */

                const LWPOINT* p = (LWPOINT*)lwgeom_subgeom(ep, pn);

                nl = lwgeom_ngeoms(lines);
                for (ln=0; ln<nl; ++ln) { /* for each line */

                        const LWLINE* l = (LWLINE*)lwgeom_subgeom(lines, ln);

                        int s = lwline_split_by_point_to(l, p, (LWMLINE*)col);

                        if ( ! s ) continue; /* not on this line */

                        if ( s == 1 ) {
                                /* found on this line, but not splitting it */
                                break;
                        }

                        /* splits this line */

                        /* replace this line with the two splits */
                        if ( lwgeom_is_collection(lines) ) {
                                tc = (LWCOLLECTION*)lines;
                                lwcollection_reserve(tc, nl + 1);
                                while (nl > ln+1) {
                                        tc->geoms[nl] = tc->geoms[nl-1];
                                        --nl;
                                }
                                lwgeom_free(tc->geoms[ln]);
                                tc->geoms[ln]   = col->geoms[0];
                                tc->geoms[ln+1] = col->geoms[1];
                                tc->ngeoms++;
                        } else {
                                lwgeom_free(lines);
                                /* transfer ownership rather than cloning */
                                lines = (LWGEOM*)lwcollection_clone_deep(col);
                                assert(col->ngeoms == 2);
                                lwgeom_free(col->geoms[0]);
                                lwgeom_free(col->geoms[1]);
                        }

                        /* reset the vector */
                        assert(col->ngeoms == 2);
                        col->ngeoms = 0;

                        break;
                }

        }

        lwgeom_free(ep);
        lwcollection_free(col);

        lines->srid = lwgeom_in->srid;
        return (LWGEOM*)lines;
}

Here is the call graph for this function:

Here is the caller graph for this function: