gserialized1_peek_gbox_p()

int gserialized1_peek_gbox_p	(	const GSERIALIZED *	g,
		GBOX *	gbox
	)

Definition at line 299 of file gserialized1.c.

{
        uint32_t type = gserialized1_get_type(g);
 
        /* Peeking doesn't help if you already have a box or are geodetic */
        if ( G1FLAGS_GET_GEODETIC(g->gflags) || G1FLAGS_GET_BBOX(g->gflags) )
        {
                return LW_FAILURE;
        }
 
        /* Boxes of points are easy peasy */
        if ( type == POINTTYPE )
        {
                int i = 1; /* Start past <pointtype><padding> */
                double *dptr = (double*)(g->data);
 
                /* Read the empty flag */
                int32_t *iptr = (int32_t *)(g->data);
                int isempty = (iptr[1] == 0);
 
                /* EMPTY point has no box */
                if ( isempty ) return LW_FAILURE;
 
                gbox->xmin = gbox->xmax = dptr[i++];
                gbox->ymin = gbox->ymax = dptr[i++];
                gbox->flags = gserialized1_get_lwflags(g);
                if ( G1FLAGS_GET_Z(g->gflags) )
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if ( G1FLAGS_GET_M(g->gflags) )
                {
                        gbox->mmin = gbox->mmax = dptr[i++];
                }
                gbox_float_round(gbox);
                return LW_SUCCESS;
        }
        /* We can calculate the box of a two-point cartesian line trivially */
        else if ( type == LINETYPE )
        {
                int ndims = G1FLAGS_NDIMS(g->gflags);
                int i = 0; /* Start at <linetype><npoints> */
                double *dptr = (double*)(g->data);
                int32_t *iptr = (int32_t *)(g->data);
                int npoints = iptr[1]; /* Read the npoints */
 
                /* This only works with 2-point lines */
                if ( npoints != 2 )
                        return LW_FAILURE;
 
                /* Advance to X */
                /* Past <linetype><npoints> */
                i++;
                gbox->xmin = FP_MIN(dptr[i], dptr[i+ndims]);
                gbox->xmax = FP_MAX(dptr[i], dptr[i+ndims]);
 
                /* Advance to Y */
                i++;
                gbox->ymin = FP_MIN(dptr[i], dptr[i+ndims]);
                gbox->ymax = FP_MAX(dptr[i], dptr[i+ndims]);
 
                gbox->flags = gserialized1_get_lwflags(g);
                if ( G1FLAGS_GET_Z(g->gflags) )
                {
                        /* Advance to Z */
                        i++;
                        gbox->zmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->zmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                if ( G1FLAGS_GET_M(g->gflags) )
                {
                        /* Advance to M */
                        i++;
                        gbox->mmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->mmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                gbox_float_round(gbox);
                return LW_SUCCESS;
        }
        /* We can also do single-entry multi-points */
        else if ( type == MULTIPOINTTYPE )
        {
                int i = 0; /* Start at <multipointtype><ngeoms> */
                double *dptr = (double*)(g->data);
                int32_t *iptr = (int32_t *)(g->data);
                int ngeoms = iptr[1]; /* Read the ngeoms */
                int npoints;
 
                /* This only works with single-entry multipoints */
                if ( ngeoms != 1 )
                        return LW_FAILURE;
 
                /* Npoints is at <multipointtype><ngeoms><pointtype><npoints> */
                npoints = iptr[3];
 
                /* The check below is necessary because we can have a MULTIPOINT
                 * that contains a single, empty POINT (ngeoms = 1, npoints = 0) */
                if ( npoints != 1 )
                        return LW_FAILURE;
 
                /* Move forward two doubles (four ints) */
                /* Past <multipointtype><ngeoms> */
                /* Past <pointtype><npoints> */
                i += 2;
 
                /* Read the doubles from the one point */
                gbox->xmin = gbox->xmax = dptr[i++];
                gbox->ymin = gbox->ymax = dptr[i++];
                gbox->flags = gserialized1_get_lwflags(g);
                if ( G1FLAGS_GET_Z(g->gflags) )
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if ( G1FLAGS_GET_M(g->gflags) )
                {
                        gbox->mmin = gbox->mmax = dptr[i++];
                }
                gbox_float_round(gbox);
                return LW_SUCCESS;
        }
        /* And we can do single-entry multi-lines with two vertices (!!!) */
        else if ( type == MULTILINETYPE )
        {
                int ndims = G1FLAGS_NDIMS(g->gflags);
                int i = 0; /* Start at <multilinetype><ngeoms> */
                double *dptr = (double*)(g->data);
                int32_t *iptr = (int32_t *)(g->data);
                int ngeoms = iptr[1]; /* Read the ngeoms */
                int npoints;
 
                /* This only works with 1-line multilines */
                if ( ngeoms != 1 )
                        return LW_FAILURE;
 
                /* Npoints is at <multilinetype><ngeoms><linetype><npoints> */
                npoints = iptr[3];
 
                if ( npoints != 2 )
                        return LW_FAILURE;
 
                /* Advance to X */
                /* Move forward two doubles (four ints) */
                /* Past <multilinetype><ngeoms> */
                /* Past <linetype><npoints> */
                i += 2;
                gbox->xmin = FP_MIN(dptr[i], dptr[i+ndims]);
                gbox->xmax = FP_MAX(dptr[i], dptr[i+ndims]);
 
                /* Advance to Y */
                i++;
                gbox->ymin = FP_MIN(dptr[i], dptr[i+ndims]);
                gbox->ymax = FP_MAX(dptr[i], dptr[i+ndims]);
 
                gbox->flags = gserialized1_get_lwflags(g);
                if ( G1FLAGS_GET_Z(g->gflags) )
                {
                        /* Advance to Z */
                        i++;
                        gbox->zmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->zmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                if ( G1FLAGS_GET_M(g->gflags) )
                {
                        /* Advance to M */
                        i++;
                        gbox->mmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->mmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                gbox_float_round(gbox);
                return LW_SUCCESS;
        }
 
        return LW_FAILURE;
}

References GSERIALIZED::data, GBOX::flags, FP_MAX, FP_MIN, G1FLAGS_GET_BBOX, G1FLAGS_GET_GEODETIC, G1FLAGS_GET_M, G1FLAGS_GET_Z, G1FLAGS_NDIMS, gbox_float_round(), GSERIALIZED::gflags, gserialized1_get_lwflags(), gserialized1_get_type(), LINETYPE, LW_FAILURE, LW_SUCCESS, GBOX::mmax, GBOX::mmin, MULTILINETYPE, MULTIPOINTTYPE, POINTTYPE, GBOX::xmax, GBOX::xmin, GBOX::ymax, GBOX::ymin, GBOX::zmax, and GBOX::zmin.

Referenced by gserialized1_fast_gbox_p(), gserialized1_get_gbox_p(), test_gserialized1_peek_gbox_p_fails_for_unsupported_cases(), test_gserialized1_peek_gbox_p_gets_correct_box(), and test_gserialized1_peek_gbox_p_no_box_when_empty().

Here is the call graph for this function:

Here is the caller graph for this function: