ptarray_grid_in_place()

void ptarray_grid_in_place	(	POINTARRAY *	pa,
		const gridspec *	grid
	)

Snap to grid.

Definition at line 1978 of file ptarray.c.

{
        uint32_t i, j = 0;
        POINT4D *p, *p_out = NULL;
        int ndims = FLAGS_NDIMS(pa->flags);
        int has_z = FLAGS_GET_Z(pa->flags);
        int has_m = FLAGS_GET_M(pa->flags);
 
        LWDEBUGF(2, "%s called on %p", __func__, pa);
 
        for (i = 0; i < pa->npoints; i++)
        {
                /* Look straight into the abyss */
                p = (POINT4D*)(getPoint_internal(pa, i));
 
                if (grid->xsize > 0)
                {
                        p->x = rint((p->x - grid->ipx)/grid->xsize) * grid->xsize + grid->ipx;
                }
 
                if (grid->ysize > 0)
                {
                        p->y = rint((p->y - grid->ipy)/grid->ysize) * grid->ysize + grid->ipy;
                }
 
                /* Read and round this point */
                /* Z is always in third position */
                if (has_z)
                {
                        if (grid->zsize > 0)
                                p->z = rint((p->z - grid->ipz)/grid->zsize) * grid->zsize + grid->ipz;
                }
                /* M might be in 3rd or 4th position */
                if (has_m)
                {
                        /* In POINT M, M is in 3rd position */
                        if (grid->msize > 0 && !has_z)
                                p->z = rint((p->z - grid->ipm)/grid->msize) * grid->msize + grid->ipm;
                        /* In POINT ZM, M is in 4th position */
                        if (grid->msize > 0 && has_z)
                                p->m = rint((p->m - grid->ipm)/grid->msize) * grid->msize + grid->ipm;
                }
 
                /* Skip duplicates */
                if ( p_out && FP_EQUALS(p_out->x, p->x) && FP_EQUALS(p_out->y, p->y)
                   && (ndims > 2 ? FP_EQUALS(p_out->z, p->z) : 1)
                   && (ndims > 3 ? FP_EQUALS(p_out->m, p->m) : 1) )
                {
                        continue;
                }
 
                /* Write rounded values into the next available point */
                p_out = (POINT4D*)(getPoint_internal(pa, j++));
                p_out->x = p->x;
                p_out->y = p->y;
                if (ndims > 2)
                        p_out->z = p->z;
                if (ndims > 3)
                        p_out->m = p->m;
        }
 
        /* Update output ptarray length */
        pa->npoints = j;
        return;
}

References POINTARRAY::flags, FLAGS_GET_M, FLAGS_GET_Z, FLAGS_NDIMS, FP_EQUALS, getPoint_internal(), gridspec_t::ipm, gridspec_t::ipx, gridspec_t::ipy, gridspec_t::ipz, LWDEBUGF, POINT4D::m, gridspec_t::msize, POINTARRAY::npoints, POINT4D::x, gridspec_t::xsize, POINT4D::y, gridspec_t::ysize, POINT4D::z, and gridspec_t::zsize.

Referenced by lwgeom_grid_in_place().

Here is the call graph for this function:

Here is the caller graph for this function: