gserialized2_peek_gbox_p()

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

Definition at line 360 of file gserialized2.c.

{
        uint32_t type = gserialized2_get_type(g);
        uint8_t *geometry_start = gserialized2_get_geometry_p(g);
        double *dptr = (double *)(geometry_start);
        int32_t *iptr = (int32_t *)(geometry_start);
 
        /* Peeking doesn't help if you already have a box or are geodetic */
        if (G2FLAGS_GET_GEODETIC(g->gflags) || G2FLAGS_GET_BBOX(g->gflags))
        {
                return LW_FAILURE;
        }
 
        /* Boxes of points are easy peasy */
        if (type == POINTTYPE)
        {
                int i = 1; /* Start past <pointtype><padding> */
 
                /* Read the npoints flag */
                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 = gserialized2_get_lwflags(g);
                if (G2FLAGS_GET_Z(g->gflags))
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if (G2FLAGS_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 = G2FLAGS_NDIMS(g->gflags);
                int i = 0; /* Start at <linetype><npoints> */
                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 = gserialized2_get_lwflags(g);
                if (G2FLAGS_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 (G2FLAGS_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> */
                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 = gserialized2_get_lwflags(g);
                if (G2FLAGS_GET_Z(g->gflags))
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if (G2FLAGS_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 = G2FLAGS_NDIMS(g->gflags);
                int i = 0; /* Start at <multilinetype><ngeoms> */
                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 = gserialized2_get_lwflags(g);
                if (G2FLAGS_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 (G2FLAGS_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 GBOX::flags, FP_MAX, FP_MIN, G2FLAGS_GET_BBOX, G2FLAGS_GET_GEODETIC, G2FLAGS_GET_M, G2FLAGS_GET_Z, G2FLAGS_NDIMS, gbox_float_round(), GSERIALIZED::gflags, gserialized2_get_geometry_p(), gserialized2_get_lwflags(), gserialized2_get_type(), LINETYPE, LW_FAILURE, LW_SUCCESS, GBOX::mmax, GBOX::mmin, MULTILINETYPE, MULTIPOINTTYPE, POINTTYPE, ovdump::type, GBOX::xmax, GBOX::xmin, GBOX::ymax, GBOX::ymin, GBOX::zmax, and GBOX::zmin.

Referenced by gserialized2_fast_gbox_p(), gserialized2_get_gbox_p(), test_gserialized2_peek_gbox_p_fails_for_unsupported_cases(), test_gserialized2_peek_gbox_p_gets_correct_box(), and test_gserialized2_peek_gbox_p_no_box_when_empty().

Here is the call graph for this function:

Here is the caller graph for this function: