gserialized_peek_gbox_p()

static int gserialized_peek_gbox_p ( const GSERIALIZED *  g, GBOX *  gbox  )

static

Definition at line 463 of file g_serialized.c.

References GSERIALIZED::data, GBOX::flags, GSERIALIZED::flags, FLAGS_GET_BBOX, FLAGS_GET_GEODETIC, FLAGS_GET_M, FLAGS_GET_Z, FLAGS_NDIMS, FP_MAX, FP_MIN, gbox_float_round(), gserialized_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 gserialized_get_gbox_p(), test_gserialized_peek_gbox_p_fails_for_unsupported_cases(), test_gserialized_peek_gbox_p_gets_correct_box(), and test_gserialized_peek_gbox_p_no_box_when_empty().

{
        uint32_t type = gserialized_get_type(g);

        /* Peeking doesn't help if you already have a box or are geodetic */
        if ( FLAGS_GET_GEODETIC(g->flags) || FLAGS_GET_BBOX(g->flags) )
        {
                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 */
                int *iptr = (int*)(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 = g->flags;
                if ( FLAGS_GET_Z(g->flags) )
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if ( FLAGS_GET_M(g->flags) )
                {
                        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 = FLAGS_NDIMS(g->flags);
                int i = 0; /* Start at <linetype><npoints> */
                double *dptr = (double*)(g->data);
                int *iptr = (int*)(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 = g->flags;
                if ( FLAGS_GET_Z(g->flags) )
                {
                        /* Advance to Z */
                        i++;
                        gbox->zmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->zmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                if ( FLAGS_GET_M(g->flags) )
                {
                        /* 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);
                int *iptr = (int*)(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 = g->flags;
                if ( FLAGS_GET_Z(g->flags) )
                {
                        gbox->zmin = gbox->zmax = dptr[i++];
                }
                if ( FLAGS_GET_M(g->flags) )
                {
                        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 = FLAGS_NDIMS(g->flags);
                int i = 0; /* Start at <multilinetype><ngeoms> */
                double *dptr = (double*)(g->data);
                int *iptr = (int*)(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 = g->flags;
                if ( FLAGS_GET_Z(g->flags) )
                {
                        /* Advance to Z */
                        i++;
                        gbox->zmin = FP_MIN(dptr[i], dptr[i+ndims]);
                        gbox->zmax = FP_MAX(dptr[i], dptr[i+ndims]);
                }
                if ( FLAGS_GET_M(g->flags) )
                {
                        /* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function: