GeneratePolygonGeometry()

int GeneratePolygonGeometry	(	SHPLOADERSTATE *	state,
		SHPObject *	obj,
		char **	geometry
	)

Generate an allocated geometry string for shapefile object obj using the state parameters.

This function basically deals with the polygon case. It sorts the polys in order of outer, inner,inner, so that inners always come after outers they are within.

Definition at line 616 of file shp2pgsql-core.c.

References _, shp_loader_state::config, FindPolygons(), FLAGS_SET_M, FLAGS_SET_Z, shp_loader_state::from_srid, shp_loader_state::has_m, shp_loader_state::has_z, struct_ring::list, LW_TRUE, lwcollection_as_lwgeom(), lwcollection_construct(), lwfree(), lwgeom_free(), lwgeom_to_hexwkb(), lwgeom_to_wkt(), lwpoly_add_ring(), lwpoly_as_lwgeom(), lwpoly_construct_empty(), struct_point::m, POINT4D::m, malloc(), shp_loader_state::message, MULTIPOLYGONTYPE, struct_ring::n, struct_ring::next, ptarray_append_point(), ptarray_construct_empty(), ReleasePolygons(), SHPLOADERERR, SHPLOADERMSGLEN, SHPLOADEROK, shp_loader_config::simple_geometries, shp_loader_config::use_wkt, WKB_EXTENDED, WKT_EXTENDED, WKT_PRECISION, struct_point::x, POINT4D::x, struct_point::y, POINT4D::y, struct_point::z, and POINT4D::z.

Referenced by ShpLoaderGenerateSQLRowStatement().

{
        Ring **Outer;
        int polygon_total, ring_total;
        int pi, vi; /* part index and vertex index */

        LWGEOM **lwpolygons;
        LWGEOM *lwgeom;

        POINT4D point4d;

        int dims = 0;

        char *mem;
        size_t mem_length;

        FLAGS_SET_Z(dims, state->has_z);
        FLAGS_SET_M(dims, state->has_m);

        polygon_total = FindPolygons(obj, &Outer);

        if (state->config->simple_geometries == 1 && polygon_total != 1) /* We write Non-MULTI geometries, but have several parts: */
        {
                snprintf(state->message, SHPLOADERMSGLEN, _("We have a Multipolygon with %d parts, can't use -S switch!"), polygon_total);

                return SHPLOADERERR;
        }

        /* Allocate memory for our array of LWPOLYs */
        lwpolygons = malloc(sizeof(LWPOLY *) * polygon_total);

        /* Cycle through each individual polygon */
        for (pi = 0; pi < polygon_total; pi++)
        {
                LWPOLY *lwpoly = lwpoly_construct_empty(state->from_srid, state->has_z, state->has_m);

                Ring *polyring;
                int ring_index = 0;

                /* Firstly count through the total number of rings in this polygon */
                ring_total = 0;
                polyring = Outer[pi];
                while (polyring)
                {
                        ring_total++;
                        polyring = polyring->next;
                }

                /* Cycle through each ring within the polygon, starting with the outer */
                polyring = Outer[pi];

                while (polyring)
                {
                        /* Create a POINTARRAY containing the points making up the ring */
                        POINTARRAY *pa = ptarray_construct_empty(state->has_z, state->has_m, polyring->n);

                        for (vi = 0; vi < polyring->n; vi++)
                        {
                                /* Build up a point array of all the points in this ring */
                                point4d.x = polyring->list[vi].x;
                                point4d.y = polyring->list[vi].y;

                                if (state->has_z)
                                        point4d.z = polyring->list[vi].z;
                                if (state->has_m)
                                        point4d.m = polyring->list[vi].m;

                                ptarray_append_point(pa, &point4d, LW_TRUE);
                        }

                        /* Copy the POINTARRAY pointer so we can use the LWPOLY constructor */
                        lwpoly_add_ring(lwpoly, pa);

                        polyring = polyring->next;
                        ring_index++;
                }

                /* Generate the LWGEOM */
                lwpolygons[pi] = lwpoly_as_lwgeom(lwpoly);
        }

        /* If using MULTIPOLYGONS then generate the serialized collection, otherwise just a single POLYGON */
        if (state->config->simple_geometries == 0)
        {
                lwgeom = lwcollection_as_lwgeom(lwcollection_construct(MULTIPOLYGONTYPE, state->from_srid, NULL, polygon_total, lwpolygons));
        }
        else
        {
                lwgeom = lwpolygons[0];
                lwfree(lwpolygons);
        }

        if (!state->config->use_wkt)
                mem = lwgeom_to_hexwkb(lwgeom, WKB_EXTENDED, &mem_length);
        else
                mem = lwgeom_to_wkt(lwgeom, WKT_EXTENDED, WKT_PRECISION, &mem_length);

        if ( !mem )
        {
                /* Free the linked list of rings */
                ReleasePolygons(Outer, polygon_total);

                snprintf(state->message, SHPLOADERMSGLEN, "unable to write geometry");
                return SHPLOADERERR;
        }

        /* Free all of the allocated items */
        lwgeom_free(lwgeom);

        /* Free the linked list of rings */
        ReleasePolygons(Outer, polygon_total);

        /* Return the string - everything ok */
        *geometry = mem;

        return SHPLOADEROK;
}

Here is the call graph for this function:

Here is the caller graph for this function: