create_multipolygon()

static SHPObject * create_multipolygon ( SHPDUMPERSTATE *  state, LWMPOLY *  lwmultipolygon  )

static

Definition at line 245 of file pgsql2shp-core.c.

References free(), LWMPOLY::geoms, getPoint4d(), is_clockwise(), LWDEBUG, LWDEBUGF, POINT4D::m, malloc(), LWMPOLY::ngeoms, POINTARRAY::npoints, LWPOLY::nrings, shp_dumper_state::outshptype, reverse_points(), LWPOLY::rings, SHPCreateObject(), POINT4D::x, POINT4D::y, and POINT4D::z.

Referenced by ShpLoaderGenerateShapeRow().

{
        SHPObject *obj;
        POINT4D p4d;
        int i, j, k;

        double *xpts, *ypts, *zpts, *mpts;

        int *shpparts, shppointtotal = 0, shppoint = 0, shpringtotal = 0, shpring = 0;

        /* NOTE: Multipolygons are stored in shapefiles as Polygon* shapes with multiple outer rings */

        /* First count through each ring of each polygon so we now know much memory is required */
        for (i = 0; i < lwmultipolygon->ngeoms; i++)
        {
                for (j = 0; j < lwmultipolygon->geoms[i]->nrings; j++)
                {
                        shpringtotal++;
                        shppointtotal += lwmultipolygon->geoms[i]->rings[j]->npoints;
                }
        }

        /* Allocate storage for ring pointers */
        shpparts = malloc(sizeof(int) * shpringtotal);

        /* Allocate storage for points */
        xpts = malloc(sizeof(double) * shppointtotal);
        ypts = malloc(sizeof(double) * shppointtotal);
        zpts = malloc(sizeof(double) * shppointtotal);
        mpts = malloc(sizeof(double) * shppointtotal);

        LWDEBUGF(4, "Total number of rings: %d   Total number of points: %d", shpringtotal, shppointtotal);

        /* Iterate through each ring of each polygon in turn */
        for (i = 0; i < lwmultipolygon->ngeoms; i++)
        {
                for (j = 0; j < lwmultipolygon->geoms[i]->nrings; j++)
                {
                        /* For each ring, store the integer coordinate offset for the start of each ring */
                        shpparts[shpring] = shppoint;

                        LWDEBUGF(4, "Ring offset: %d", shpring);

                        for (k = 0; k < lwmultipolygon->geoms[i]->rings[j]->npoints; k++)
                        {
                                p4d = getPoint4d(lwmultipolygon->geoms[i]->rings[j], k);

                                xpts[shppoint] = p4d.x;
                                ypts[shppoint] = p4d.y;
                                zpts[shppoint] = p4d.z;
                                mpts[shppoint] = p4d.m;

                                LWDEBUGF(4, "MultiPolygon %d Polygon Ring %d - Point: %g %g %g %g", i, j, xpts[shppoint], ypts[shppoint], zpts[shppoint], mpts[shppoint]);

                                /* Increment the point counter */
                                shppoint++;
                        }

                        /*
                        * First ring should be clockwise,
                        * other rings should be counter-clockwise
                        */
                        if ( j == 0 )
                        {
                                if ( ! is_clockwise(lwmultipolygon->geoms[i]->rings[j]->npoints,
                                                    &xpts[shpparts[shpring]], &ypts[shpparts[shpring]], NULL) )
                                {
                                        LWDEBUG(4, "Outer ring not clockwise, forcing clockwise\n");

                                        reverse_points(lwmultipolygon->geoms[i]->rings[j]->npoints,
                                                       &xpts[shpparts[shpring]], &ypts[shpparts[shpring]],
                                                       &zpts[shpparts[shpring]], &mpts[shpparts[shpring]]);
                                }
                        }
                        else
                        {
                                if ( is_clockwise(lwmultipolygon->geoms[i]->rings[j]->npoints,
                                                  &xpts[shpparts[shpring]], &ypts[shpparts[shpring]], NULL) )
                                {
                                        LWDEBUGF(4, "Inner ring %d not counter-clockwise, forcing counter-clockwise\n", i);

                                        reverse_points(lwmultipolygon->geoms[i]->rings[j]->npoints,
                                                       &xpts[shpparts[shpring]], &ypts[shpparts[shpring]],
                                                       &zpts[shpparts[shpring]], &mpts[shpparts[shpring]]);
                                }
                        }

                        /* Increment the ring counter */
                        shpring++;
                }
        }

        obj = SHPCreateObject(state->outshptype, -1, shpringtotal, shpparts, NULL, shppointtotal, xpts, ypts, zpts, mpts);

        free(xpts);
        free(ypts);
        free(zpts);
        free(mpts);
        free(shpparts);

        return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function: