gserialized2_set_gbox()

GSERIALIZED* gserialized2_set_gbox	(	GSERIALIZED *	g,
		GBOX *	gbox
	)

Update the bounding box of a GSERIALIZED, allocating a fresh one if there is not enough space to just write the new box in.

Copy a new bounding box into an existing gserialized.

WARNING if a new object needs to be created, the input pointer will have to be freed by the caller! Check to see if input == output. Returns null if there's a problem like mismatched dimensions.

Definition at line 1561 of file gserialized2.c.

{
 
        int g_ndims = G2FLAGS_NDIMS_BOX(g->gflags);
        int box_ndims = FLAGS_NDIMS_BOX(gbox->flags);
        GSERIALIZED *g_out = NULL;
        size_t box_size = 2 * g_ndims * sizeof(float);
        float *fbox;
        int fbox_pos = 0;
 
        /* The dimensionality of the inputs has to match or we are SOL. */
        if (g_ndims != box_ndims)
        {
                return NULL;
        }
 
        /* Serialized already has room for a box. */
        if (G2FLAGS_GET_BBOX(g->gflags))
        {
                g_out = g;
        }
        /* Serialized has no box. We need to allocate enough space for the old
           data plus the box, and leave a gap in the memory segment to write
           the new values into.
        */
        else
        {
                size_t varsize_in = LWSIZE_GET(g->size);
                size_t varsize_out = varsize_in + box_size;
                uint8_t *ptr_out, *ptr_in, *ptr;
                g_out = lwalloc(varsize_out);
                ptr_out = (uint8_t*)g_out;
                ptr = ptr_in = (uint8_t*)g;
                /* Copy the head of g into place */
                memcpy(ptr_out, ptr_in, 8); ptr_out += 8; ptr_in += 8;
                /* Optionally copy extended bit into place */
                if (G2FLAGS_GET_EXTENDED(g->gflags))
                {
                        memcpy(ptr_out, ptr_in, 8); ptr_out += 8; ptr_in += 8;
                }
                /* Copy the body of g into place after leaving space for the box */
                ptr_out += box_size;
                memcpy(ptr_out, ptr_in, varsize_in - (ptr_in - ptr));
                G2FLAGS_SET_BBOX(g_out->gflags, 1);
                LWSIZE_SET(g_out->size, varsize_out);
        }
 
        /* Move bounds to nearest float values */
        gbox_float_round(gbox);
        /* Now write the float box values into the memory segement */
        fbox = (float*)(g_out->data);
        /* Copy in X/Y */
        fbox[fbox_pos++] = gbox->xmin;
        fbox[fbox_pos++] = gbox->xmax;
        fbox[fbox_pos++] = gbox->ymin;
        fbox[fbox_pos++] = gbox->ymax;
        /* Optionally copy in higher dims */
        if(gserialized2_has_z(g) || gserialized2_is_geodetic(g))
        {
                fbox[fbox_pos++] = gbox->zmin;
                fbox[fbox_pos++] = gbox->zmax;
        }
        if(gserialized2_has_m(g) && ! gserialized2_is_geodetic(g))
        {
                fbox[fbox_pos++] = gbox->mmin;
                fbox[fbox_pos++] = gbox->mmax;
        }
 
        return g_out;
}

References GSERIALIZED::data, GBOX::flags, FLAGS_NDIMS_BOX, G2FLAGS_GET_BBOX, G2FLAGS_GET_EXTENDED, G2FLAGS_NDIMS_BOX, G2FLAGS_SET_BBOX, gbox_float_round(), GSERIALIZED::gflags, gserialized2_has_m(), gserialized2_has_z(), gserialized2_is_geodetic(), lwalloc(), LWSIZE_GET, LWSIZE_SET, GBOX::mmax, GBOX::mmin, GSERIALIZED::size, GBOX::xmax, GBOX::xmin, GBOX::ymax, GBOX::ymin, GBOX::zmax, and GBOX::zmin.

Referenced by gserialized_set_gbox().

Here is the call graph for this function:

Here is the caller graph for this function: