create_polygon()

static SHPObject * create_polygon ( SHPDUMPERSTATE *  state, LWPOLY *  lwpolygon  )

static

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

{
        SHPObject *obj;
        POINT4D p4d;
        uint32_t i, j;
 
        double *xpts, *ypts, *zpts, *mpts;
 
        int *shpparts, shppointtotal = 0, shppoint = 0;
 
        /* Allocate storage for ring pointers */
        shpparts = malloc(sizeof(int) * lwpolygon->nrings);
 
        /* First count through all the points in each ring so we now how much memory is required */
        for (i = 0; i < lwpolygon->nrings; i++)
                shppointtotal += lwpolygon->rings[i]->npoints;
 
        /* 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 points: %d", shppointtotal);
 
        /* Iterate through each ring setting up shpparts to point to the beginning of each ring */
        for (i = 0; i < lwpolygon->nrings; i++)
        {
                /* For each ring, store the integer coordinate offset for the start of each ring */
                shpparts[i] = shppoint;
 
                for (j = 0; j < lwpolygon->rings[i]->npoints; j++)
                {
                        p4d = getPoint4d(lwpolygon->rings[i], j);
 
                        xpts[shppoint] = p4d.x;
                        ypts[shppoint] = p4d.y;
                        zpts[shppoint] = p4d.z;
                        mpts[shppoint] = p4d.m;
 
                        LWDEBUGF(4, "Polygon Ring %d - Point: %g %g %g %g", i, 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 ( i == 0 )
                {
                        if ( ! is_clockwise(lwpolygon->rings[i]->npoints,
                                            &xpts[shpparts[i]], &ypts[shpparts[i]], NULL) )
                        {
                                LWDEBUG(4, "Outer ring not clockwise, forcing clockwise\n");
 
                                reverse_points(lwpolygon->rings[i]->npoints,
                                               &xpts[shpparts[i]], &ypts[shpparts[i]],
                                               &zpts[shpparts[i]], &mpts[shpparts[i]]);
                        }
                }
                else
                {
                        if ( is_clockwise(lwpolygon->rings[i]->npoints,
                                          &xpts[shpparts[i]], &ypts[shpparts[i]], NULL) )
                        {
                                LWDEBUGF(4, "Inner ring %d not counter-clockwise, forcing counter-clockwise\n", i);
 
                                reverse_points(lwpolygon->rings[i]->npoints,
                                               &xpts[shpparts[i]], &ypts[shpparts[i]],
                                               &zpts[shpparts[i]], &mpts[shpparts[i]]);
                        }
                }
        }
 
        obj = SHPCreateObject(state->outshptype, -1, lwpolygon->nrings, shpparts, NULL, shppointtotal, xpts, ypts, zpts, mpts);
 
        free(xpts);
        free(ypts);
        free(zpts);
        free(mpts);
        free(shpparts);
 
        return obj;
}

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

Referenced by ShpLoaderGenerateShapeRow().

Here is the call graph for this function:

Here is the caller graph for this function: