Changeset 8240 for spike

Timestamp:

11/24/11 14:04:15 (6 months ago)

Author:

pramsey

Message:

Double box experiment complete

Location:

spike/pramsey/doublebox

Files:

• liblwgeom/cunit/cu_geodetic.c (modified) (2 diffs)
• liblwgeom/cunit/cu_libgeom.c (modified) (1 diff)
• liblwgeom/g_box.c (modified) (2 diffs)
• liblwgeom/g_serialized.c (modified) (8 diffs)
• liblwgeom/liblwgeom.h.in (modified) (1 diff)
• liblwgeom/lwgeom.c (modified) (1 diff)
• libpgcommon/gserialized_gist.c (modified) (7 diffs)
• libpgcommon/gserialized_gist.h (modified) (2 diffs)
• libpgcommon/lwgeom_pg.h (modified) (1 diff)
• postgis/geography_measurement.c (modified) (1 diff)
• postgis/gserialized_gist_2d.c (modified) (2 diffs)
• postgis/gserialized_gist_nd.c (modified) (2 diffs)
• postgis/lwgeom_functions_basic.c (modified) (1 diff)
• postgis/lwgeom_inout.c (modified) (2 diffs)
• regress/lwgeom_regress_expected (modified) (1 diff)

spike/pramsey/doublebox/liblwgeom/cunit/cu_geodetic.c

@@ -582 +582 @@
         type = gserialized_get_type(g);
         CU_ASSERT_EQUAL( type, POLYGONTYPE );
-        inspect = (double*)g;
-        CU_ASSERT_EQUAL(inspect[9], 2.5);
+        /* data + box size + type + nrings + npoints1 + npoints2 */
+        inspect = (double*)(g->data + gbox_serialized_size(g->flags) + 4 + 4 + 4 + 4);
+        CU_ASSERT_EQUAL(inspect[3], 2.5);
         lwgeom_free(geom);
         lwfree(g);
@@ -592 +593 @@
         type = gserialized_get_type(g);
         CU_ASSERT_EQUAL( type, MULTILINETYPE );
-        inspect = (double*)g;
-        CU_ASSERT_EQUAL(inspect[12], 0.1);
+        /* data + box size + type + ngeoms + subtype + npoints + 2 points + type + npoints */
+        inspect = (double*)(g->data + gbox_serialized_size(g->flags) + 4 + 4 + 4 + 4 + 8*4 + 4 + 4);
+        CU_ASSERT_EQUAL(inspect[1], 0.1);
         lwgeom_free(geom);
         lwfree(g);

spike/pramsey/doublebox/liblwgeom/cunit/cu_libgeom.c

@@ -172 +172 @@
 {
         uint8_t flags = gflags(0, 0, 0);
-        CU_ASSERT_EQUAL(gbox_serialized_size(flags),16);
+        CU_ASSERT_EQUAL(gbox_serialized_size(flags),32);
         FLAGS_SET_BBOX(flags, 1);
-        CU_ASSERT_EQUAL(gbox_serialized_size(flags),16);
+        CU_ASSERT_EQUAL(gbox_serialized_size(flags),32);
         FLAGS_SET_Z(flags, 1);
-        CU_ASSERT_EQUAL(gbox_serialized_size(flags),24);
+        CU_ASSERT_EQUAL(gbox_serialized_size(flags),48);
         FLAGS_SET_M(flags, 1);
-        CU_ASSERT_EQUAL(gbox_serialized_size(flags),32);
+        CU_ASSERT_EQUAL(gbox_serialized_size(flags),64);
         FLAGS_SET_GEODETIC(flags, 1);
-        CU_ASSERT_EQUAL(gbox_serialized_size(flags),24);
+        CU_ASSERT_EQUAL(gbox_serialized_size(flags),48);
 
 }

spike/pramsey/doublebox/liblwgeom/g_box.c

@@ -78 +78 @@
         g->ymin -= d;
         g->ymax += d;
-        if ( FLAGS_GET_Z(g->flags) )
+        if ( FLAGS_GET_GEODETIC(g->flags) )
         {
                 g->zmin -= d;
                 g->zmax += d;
         }
-        if ( FLAGS_GET_M(g->flags) )
-        {
-                g->mmin -= d;
-                g->mmax += d;
+        else
+        {
+                if ( FLAGS_GET_Z(g->flags) )
+                {
+                        g->zmin -= d;
+                        g->zmax += d;
+                }
+                if ( FLAGS_GET_M(g->flags) )
+                {
+                        g->mmin -= d;
+                        g->mmax += d;
+                }
         }
 }
@@ -296 +304 @@
 {
         if ( FLAGS_GET_GEODETIC(flags) )
-                return 6 * sizeof(float);
+                return 6 * sizeof(double);
         else
-                return 2 * FLAGS_NDIMS(flags) * sizeof(float);
+                return 2 * FLAGS_NDIMS(flags) * sizeof(double);
 }
 

spike/pramsey/doublebox/liblwgeom/g_serialized.c

@@ -156 +156 @@
         {
                 int i = 0;
-                float *fbox = (float*)(g->data);
+                double *fbox = (double*)(g->data);
                 gbox->xmin = fbox[i++];
                 gbox->xmax = fbox[i++];
@@ -202 +202 @@
                                 gbox->mmin = gbox->mmax = dptr[i++];
                         }
-                        gbox_float_round(gbox);
+//                      gbox_float_round(gbox);
                         return LW_SUCCESS;
                 }
@@ -242 +242 @@
                                 gbox->zmax = FP_MAX(dptr[i], dptr[i+ndims]);
                         }
-                        gbox_float_round(gbox);
+//                      gbox_float_round(gbox);
                         return LW_SUCCESS;
                 }
@@ -251 +251 @@
                         return LW_FAILURE;
                 }
+                /* We could also do single-entry two-point multi-linestrings */
+                else if ( type == MULTILINETYPE )
+                {
+                        /* TODO: Make this actually happen */
+                        return LW_FAILURE;
+                }
         }
         return LW_FAILURE;
@@ -268 +274 @@
                 lwgeom = lwgeom_from_gserialized(geom);
                 ret = lwgeom_calculate_gbox(lwgeom, box);
-                gbox_float_round(box);
+//              gbox_float_round(box);
                 lwgeom_free(lwgeom);
         }
@@ -716 +722 @@
 }
 
-static size_t gserialized_from_gbox(const GBOX *gbox, uint8_t *buf)
-{
-        uint8_t *loc = buf;
-        float f;
+size_t gserialized_from_gbox(const GBOX *gbox, uint8_t *buf)
+{
+        double* loc = (double*)buf;
         size_t return_size;
 
         assert(buf);
 
-        f = next_float_down(gbox->xmin);
-        memcpy(loc, &f, sizeof(float));
-        loc += sizeof(float);
-
-        f = next_float_up(gbox->xmax);
-        memcpy(loc, &f, sizeof(float));
-        loc += sizeof(float);
-
-        f = next_float_down(gbox->ymin);
-        memcpy(loc, &f, sizeof(float));
-        loc += sizeof(float);
-
-        f = next_float_up(gbox->ymax);
-        memcpy(loc, &f, sizeof(float));
-        loc += sizeof(float);
+        *loc = gbox->xmin; loc++;
+        *loc = gbox->xmax; loc++;
+        *loc = gbox->ymin; loc++;
+        *loc = gbox->ymax; loc++;
 
         if ( FLAGS_GET_GEODETIC(gbox->flags) )
         {
-                f = next_float_down(gbox->zmin);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-
-                f = next_float_up(gbox->zmax);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-
-                return_size = (size_t)(loc - buf);
+                *loc = gbox->zmin; loc++;
+                *loc = gbox->zmax; loc++;
+
+                return_size = (size_t)(((uint8_t*)loc) - buf);
                 LWDEBUGF(4, "returning size %d", return_size);
                 return return_size;
@@ -757 +746 @@
         if ( FLAGS_GET_Z(gbox->flags) )
         {
-                f = next_float_down(gbox->zmin);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-
-                f = next_float_up(gbox->zmax);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-
+                *loc = gbox->zmin; loc++;
+                *loc = gbox->zmax; loc++;
         }
 
         if ( FLAGS_GET_M(gbox->flags) )
         {
-                f = next_float_down(gbox->mmin);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-
-                f = next_float_up(gbox->mmax);
-                memcpy(loc, &f, sizeof(float));
-                loc += sizeof(float);
-        }
-        return_size = (size_t)(loc - buf);
+                *loc = gbox->mmin; loc++;
+                *loc = gbox->mmax; loc++;
+        }
+        return_size = (size_t)(((uint8_t*)loc) - buf);
         LWDEBUGF(4, "returning size %d", return_size);
         return return_size;
@@ -796 +774 @@
         ** See if we need a bounding box, add one if we don't have one.
         */
-        if ( (! geom->bbox) && lwgeom_needs_bbox(geom) && (!lwgeom_is_empty(geom)) )
-        {
+        if ( lwgeom_needs_bbox(geom) )
                 lwgeom_add_bbox(geom);
-        }
+//      else
+//              lwgeom_drop_bbox(geom);
         
         /*

spike/pramsey/doublebox/liblwgeom/liblwgeom.h.in

@@ -1384 +1384 @@
 
 /**
+* Write a serialized box into a byte buffer and return the size of
+* the segment written.
+*/
+extern size_t gserialized_from_gbox(const GBOX *gbox, uint8_t *buf);
+
+/**
 * Return a copy of the input serialized geometry. 
 */ 

spike/pramsey/doublebox/liblwgeom/lwgeom.c

@@ -912 +912 @@
 {
         assert(geom);
-        if ( geom->type == POINTTYPE )
+        if ( geom->type == POINTTYPE || lwgeom_is_empty(geom) )
         {
                 return LW_FALSE;
         }
+
         return LW_TRUE;
 }

spike/pramsey/doublebox/libpgcommon/gserialized_gist.c

@@ -49 +49 @@
 #endif
 
+/**
+* How many dimensions should a bounding box for this flag set have?
+* Geodetic objects always have 3D boxes. Other objects have boxes
+* with the same dimensionality as their coordinates.
+*/
+static inline int
+gbox_ndims(uint8_t flags)
+{
+        return FLAGS_GET_GEODETIC(flags) ? 3 : FLAGS_NDIMS(flags);
+}
 
 /**
 * Given a #GSERIALIZED datum, as quickly as possible (peaking into the top
 * of the memory) return the gbox extents. Does not deserialize the geometry,
-* but <em>WARNING</em> returns a slightly larger bounding box than actually
-* encompasses the objects. For geography objects returns geocentric bounding
+* For geography objects returns geocentric bounding
 * box, for geometry objects returns cartesian bounding box.
 */
@@ -60 +69 @@
 gserialized_datum_get_gbox_p(Datum gsdatum, GBOX *gbox)
 {
-        char gboxmem[GIDX_MAX_SIZE];
-        GIDX *gidx = (GIDX*)gboxmem;
+        GSERIALIZED *gpart;
+        int result = LW_SUCCESS;
+
+        POSTGIS_DEBUG(4, "entered function");
+
+        /*
+        ** The most info we need is the 8 bytes of serialized header plus the 64 bytes
+        ** of floats necessary to hold the 8 floats of the largest XYZM index
+        ** bounding box, so 72 bytes.
+        */
+        gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(gsdatum, 0, 72);
+
+        POSTGIS_DEBUGF(4, "got flags %d", gpart->flags);
+
+        /* Do we even have a serialized bounding box? */
+        if ( FLAGS_GET_BBOX(gpart->flags) )
+        {
+                /* Yes! Copy it out into the GBOX! */
+                double *d = (double*)(gpart->data);
+                gbox->flags = gpart->flags;
+                gbox->xmin = *d; d++;
+                gbox->xmax = *d; d++;
+                gbox->ymin = *d; d++;
+                gbox->ymax = *d; d++;
+                
+                if ( FLAGS_GET_GEODETIC(gpart->flags) )
+                {
+                        gbox->zmin = *d; d++;
+                        gbox->zmax = *d; d++;
+                        return LW_SUCCESS;
+                }
+                if ( FLAGS_GET_Z(gpart->flags) )
+                {
+                        gbox->zmin = *d; d++;
+                        gbox->zmax = *d; d++;
+                }
+                if ( FLAGS_GET_M(gpart->flags) )
+                {
+                        gbox->mmin = *d; d++;
+                        gbox->mmax = *d; d++;
+                }
+                result = LW_SUCCESS;
+                
+        }
+        else
+        {
+                /* No, we need to calculate it from the full object. */
+                GSERIALIZED *g = (GSERIALIZED*)PG_DETOAST_DATUM(gsdatum);
+                LWGEOM *lwgeom = lwgeom_from_gserialized(g);
+                if ( lwgeom_calculate_gbox(lwgeom, gbox) == LW_FAILURE )
+                {
+                        POSTGIS_DEBUG(4, "could not calculate bbox, returning failure");
+                        lwgeom_free(lwgeom);
+                        return LW_FAILURE;
+                }
+                lwgeom_free(lwgeom);
+                result = LW_SUCCESS;
+        }
         
-        if( LW_FAILURE == gserialized_datum_get_gidx_p(gsdatum, gidx) )
-                return LW_FAILURE;
-                
-        gbox_from_gidx(gidx, gbox);
-        return LW_SUCCESS;
-}
-
+        if ( result == LW_SUCCESS )
+        {
+                POSTGIS_DEBUGF(4, "got gbox %s", gbox_to_string(gidx));
+        }
+
+        return result;
+}
 
 /**
@@ -79 +144 @@
 * like mismatched dimensions.
 */
-GSERIALIZED* gserialized_set_gidx(GSERIALIZED *g, GIDX *gidx)
-{
-        int g_ndims = (FLAGS_GET_GEODETIC(g->flags) ? 3 : FLAGS_NDIMS(g->flags));
-        int box_ndims = GIDX_NDIMS(gidx);
+GSERIALIZED* gserialized_set_gbox(GSERIALIZED *g, GBOX *gbox)
+{
+        int g_ndims = gbox_ndims(g->flags);
+        int box_ndims = gbox_ndims(gbox->flags);
         GSERIALIZED *g_out = NULL;
-        size_t box_size = 2 * g_ndims * sizeof(float);
+        size_t box_size = gbox_serialized_size(g->flags);
+        size_t write_size;
 
         /* The dimensionality of the inputs has to match or we are SOL. */
@@ -117 +183 @@
 
         /* Now write the gidx values into the memory segement */
-        memcpy(g_out->data, gidx->c, box_size);
+        write_size = gserialized_from_gbox(gbox, (uint8_t*)g_out->data);
+
+        /* Write length should match memory segment length */
+        if ( write_size != box_size )
+        {
+                return NULL;
+        }
 
         return g_out;
 }
-
 
 /**
@@ -127 +198 @@
 * allocated #GSERIALIZED every time.
 */
-GSERIALIZED* gserialized_drop_gidx(GSERIALIZED *g)
-{
-        int g_ndims = (FLAGS_GET_GEODETIC(g->flags) ? 3 : FLAGS_NDIMS(g->flags));
-        size_t box_size = 2 * g_ndims * sizeof(float);
+GSERIALIZED* gserialized_drop_gbox(GSERIALIZED *g)
+{
+        size_t box_size = gbox_serialized_size(g->flags);;
         size_t g_out_size = VARSIZE(g) - box_size;
         GSERIALIZED *g_out = palloc(g_out_size);
@@ -158 +228 @@
 
 
-/* Convert a double-based GBOX into a float-based GIDX,
-   ensuring the float box is larger than the double box */
-static int gidx_from_gbox_p(GBOX box, GIDX *a)
-{
-        int ndims;
-
-        ndims = (FLAGS_GET_GEODETIC(box.flags) ? 3 : FLAGS_NDIMS(box.flags));
+/**
+* Convert a double-based GBOX into a float-based GIDX,
+* ensuring the float box is larger than the double box 
+*/
+static int 
+gidx_from_gbox(const GBOX *box, GIDX *a)
+{
+        int ndims = gbox_ndims(box->flags);
+
         SET_VARSIZE(a, VARHDRSZ + ndims * 2 * sizeof(float));
 
-        GIDX_SET_MIN(a,0,next_float_down(box.xmin));
-        GIDX_SET_MAX(a,0,next_float_up(box.xmax));
-        GIDX_SET_MIN(a,1,next_float_down(box.ymin));
-        GIDX_SET_MAX(a,1,next_float_up(box.ymax));
+        GIDX_SET_MIN(a,0,next_float_down(box->xmin));
+        GIDX_SET_MAX(a,0,next_float_up(box->xmax));
+        GIDX_SET_MIN(a,1,next_float_down(box->ymin));
+        GIDX_SET_MAX(a,1,next_float_up(box->ymax));
 
         /* Geodetic indexes are always 3d, geocentric x/y/z */
-        if ( FLAGS_GET_GEODETIC(box.flags) )
-        {
-                GIDX_SET_MIN(a,2,next_float_down(box.zmin));
-                GIDX_SET_MAX(a,2,next_float_up(box.zmax));
+        if ( FLAGS_GET_GEODETIC(box->flags) )
+        {
+                GIDX_SET_MIN(a,2,next_float_down(box->zmin));
+                GIDX_SET_MAX(a,2,next_float_up(box->zmax));
         }
         else
         {
                 /* Cartesian with Z implies Z is third dimension */
-                if ( FLAGS_GET_Z(box.flags) )
-                {
-                        GIDX_SET_MIN(a,2,next_float_down(box.zmin));
-                        GIDX_SET_MAX(a,2,next_float_up(box.zmax));
-                        if ( FLAGS_GET_M(box.flags) )
+                if ( FLAGS_GET_Z(box->flags) )
+                {
+                        GIDX_SET_MIN(a,2,next_float_down(box->zmin));
+                        GIDX_SET_MAX(a,2,next_float_up(box->zmax));
+                        if ( FLAGS_GET_M(box->flags) )
                         {
-                                GIDX_SET_MIN(a,3,next_float_down(box.mmin));
-                                GIDX_SET_MAX(a,3,next_float_up(box.mmax));
+                                GIDX_SET_MIN(a,3,next_float_down(box->mmin));
+                                GIDX_SET_MAX(a,3,next_float_up(box->mmax));
                         }
                 }
                 /* Unless there's no Z, in which case M is third dimension */
-                else if ( FLAGS_GET_M(box.flags) )
-                {
-                        GIDX_SET_MIN(a,2,next_float_down(box.mmin));
-                        GIDX_SET_MAX(a,2,next_float_up(box.mmax));
-                }
-        }
-
-        POSTGIS_DEBUGF(5, "converted %s to %s", gbox_to_string(&box), gidx_to_string(a));
+                else if ( FLAGS_GET_M(box->flags) )
+                {
+                        GIDX_SET_MIN(a,2,next_float_down(box->mmin));
+                        GIDX_SET_MAX(a,2,next_float_up(box->mmax));
+                }
+        }
+
+        POSTGIS_DEBUGF(5, "converted %s to %s", gbox_to_string(box), gidx_to_string(a));
 
         return LW_SUCCESS;
-}
-
-
-GIDX* gidx_from_gbox(GBOX box)
-{
-        int     ndims;
-        GIDX *a;
-
-        ndims = (FLAGS_GET_GEODETIC(box.flags) ? 3 : FLAGS_NDIMS(box.flags));
-        a = gidx_new(ndims);
-        gidx_from_gbox_p(box, a);
-        return a;
 }
 
@@ -236 +296 @@
 gserialized_datum_get_gidx_p(Datum gsdatum, GIDX *gidx)
 {
-        GSERIALIZED *gpart;
-        int result = LW_SUCCESS;
-
-        POSTGIS_DEBUG(4, "entered function");
-
-        /*
-        ** The most info we need is the 8 bytes of serialized header plus the 32 bytes
-        ** of floats necessary to hold the 8 floats of the largest XYZM index
-        ** bounding box, so 40 bytes.
-        */
-        gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(gsdatum, 0, 40);
-
-        POSTGIS_DEBUGF(4, "got flags %d", gpart->flags);
-
-        /* Do we even have a serialized bounding box? */
-        if ( FLAGS_GET_BBOX(gpart->flags) )
-        {
-                /* Yes! Copy it out into the GIDX! */
-                const size_t size = gbox_serialized_size(gpart->flags);
-                POSTGIS_DEBUG(4, "copying box out of serialization");
-                memcpy(gidx->c, gpart->data, size);
-                SET_VARSIZE(gidx, VARHDRSZ + size);
-                result = LW_SUCCESS;
-        }
-        else
-        {
-                /* No, we need to calculate it from the full object. */
-                GSERIALIZED *g = (GSERIALIZED*)PG_DETOAST_DATUM(gsdatum);
-                LWGEOM *lwgeom = lwgeom_from_gserialized(g);
-                GBOX gbox;
-                if ( lwgeom_calculate_gbox(lwgeom, &gbox) == LW_FAILURE )
-                {
-                        POSTGIS_DEBUG(4, "could not calculate bbox, returning failure");
-                        lwgeom_free(lwgeom);
-                        return LW_FAILURE;
-                }
-                lwgeom_free(lwgeom);
-                result = gidx_from_gbox_p(gbox, gidx);
-        }
-        
-        if ( result == LW_SUCCESS )
-        {
-                POSTGIS_DEBUGF(4, "got gidx %s", gidx_to_string(gidx));
-        }
-
-        return result;
-}
-
-
-/*
-** Peak into a geography to find the bounding box. If the
-** box is there, copy it out and return it. If not, calculate the box from the
-** full geography and return the box based on that. If no box is available,
-** return LW_FAILURE, otherwise LW_SUCCESS.
-*/
-int gserialized_get_gidx_p(GSERIALIZED *g, GIDX *gidx)
-{
-        int result = LW_SUCCESS;
-
-        POSTGIS_DEBUG(4, "entered function");
-
-        POSTGIS_DEBUGF(4, "got flags %d", g->flags);
-
-        if ( FLAGS_GET_BBOX(g->flags) )
-        {
-                int ndims = FLAGS_NDIMS_BOX(g->flags);
-                const size_t size = 2 * ndims * sizeof(float);
-                POSTGIS_DEBUG(4, "copying box out of serialization");
-                memcpy(gidx->c, g->data, size);
-                SET_VARSIZE(gidx, VARHDRSZ + size);
-        }
-        else
-        {
-                /* No, we need to calculate it from the full object. */
-                LWGEOM *lwgeom = lwgeom_from_gserialized(g);
-                GBOX gbox;
-                if ( lwgeom_calculate_gbox(lwgeom, &gbox) == LW_FAILURE )
-                {
-                        POSTGIS_DEBUG(4, "could not calculate bbox, returning failure");
-                        lwgeom_free(lwgeom);
-                        return LW_FAILURE;
-                }
-                lwgeom_free(lwgeom);
-                result = gidx_from_gbox_p(gbox, gidx);
-        }
-        if ( result == LW_SUCCESS )
-        {
-                POSTGIS_DEBUGF(4, "got gidx %s", gidx_to_string(gidx));
-        }
-
-        return result;
+        GBOX gbox;
+
+        if ( (gserialized_datum_get_gbox_p(gsdatum, &gbox) == LW_SUCCESS) &&
+         (gidx_from_gbox(&gbox, gidx) == LW_SUCCESS) )
+        {
+                return LW_SUCCESS;
+        }
+        return LW_FAILURE;
 }
 

spike/pramsey/doublebox/libpgcommon/gserialized_gist.h

@@ -54 +54 @@
 /* Convert a gidx to a gbox */
 void gbox_from_gidx(GIDX *gidx, GBOX *gbox);
-/* Convert a gbox to a new gidx */
-GIDX* gidx_from_gbox(GBOX box);
 /* Increase the size of a GIDX */
 void gidx_expand(GIDX *a, float d);
@@ -88 +86 @@
 int gserialized_datum_get_gidx_p(Datum gserialized_datum, GIDX *gidx);
 
-/* Pull out the gidx bounding box from an already de-toasted geography */
-int gserialized_get_gidx_p(GSERIALIZED *g, GIDX *gidx);
 /* Copy a new bounding box into an existing gserialized */
-GSERIALIZED* gserialized_set_gidx(GSERIALIZED *g, GIDX *gidx);
+GSERIALIZED* gserialized_set_gbox(GSERIALIZED *g, GBOX *gbox);
 
 /* Pull out a gbox bounding box as fast as possible. */
 int gserialized_datum_get_gbox_p(Datum gsdatum, GBOX *gbox);
-/* Given two datums, do they overlap? Computed very fast using embedded boxes. */
-/* int gserialized_datum_overlaps(Datum gs1, Datum gs2); */
+
 /* Remove the box from a disk serialization */
-GSERIALIZED* gserialized_drop_gidx(GSERIALIZED *g);
+GSERIALIZED* gserialized_drop_gbox(GSERIALIZED *g);
 
 

spike/pramsey/doublebox/libpgcommon/lwgeom_pg.h

@@ -87 +87 @@
 */
 
-/**
-* Remove the embedded bounding box 
+/** 
+* Remove the box from a disk serialization 
 */
-GSERIALIZED* gserialized_drop_gidx(GSERIALIZED *g);
+GSERIALIZED* gserialized_drop_gbox(GSERIALIZED *g);
 
 /**

spike/pramsey/doublebox/postgis/geography_measurement.c

@@ -186 +186 @@
         g_out = gserialized_expand(g, distance);
 
-        /* If the expansion fails, the return our input */
+        /* If the expansion fails, then return our input */
         if ( g_out == NULL )
         {

spike/pramsey/doublebox/postgis/gserialized_gist_2d.c

@@ -203 +203 @@
 /* Convert a double-based GBOX into a float-based BOX2DF,
    ensuring the float box is larger than the double box */
-static inline int box2df_from_gbox_p(GBOX *box, BOX2DF *a)
+static inline int box2df_from_gbox_p(const GBOX *box, BOX2DF *a)
 {
         a->xmin = next_float_down(box->xmin);
@@ -479 +479 @@
 gserialized_datum_get_box2df_p(Datum gsdatum, BOX2DF *box2df)
 {
-        GSERIALIZED *gpart;
-        uint8_t flags;
-        int result = LW_SUCCESS;
-
-        POSTGIS_DEBUG(4, "entered function");
-
-        /*
-        ** The most info we need is the 8 bytes of serialized header plus the 
-        ** of floats necessary to hold the bounding box.
-        */
-        gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(gsdatum, 0, 8 + sizeof(BOX2DF));
-        flags = gpart->flags;
-
-        POSTGIS_DEBUGF(4, "got flags %d", gpart->flags);
-
-        /* Do we even have a serialized bounding box? */
-        if ( FLAGS_GET_BBOX(flags) )
-        {
-                /* Yes! Copy it out into the box! */
-                POSTGIS_DEBUG(4, "copying box out of serialization");
-                memcpy(box2df, gpart->data, sizeof(BOX2DF));
-                result = LW_SUCCESS;
-        }
-        else
-        {
-                /* No, we need to calculate it from the full object. */
-                GBOX gbox;
-                GSERIALIZED *g = (GSERIALIZED*)PG_DETOAST_DATUM(gsdatum);
-                LWGEOM *lwgeom = lwgeom_from_gserialized(g);
-                if ( lwgeom_calculate_gbox(lwgeom, &gbox) == LW_FAILURE )
-                {
-                        POSTGIS_DEBUG(4, "could not calculate bbox, returning failure");
-                        lwgeom_free(lwgeom);
-                        return LW_FAILURE;
-                }
-                lwgeom_free(lwgeom);
-                result = box2df_from_gbox_p(&gbox, box2df);
-        }
-        
-        if ( result == LW_SUCCESS )
-        {
-                POSTGIS_DEBUGF(4, "got box2df %s", box2df_to_string(box2df));
-        }
-
-        return result;
-}
+        GBOX gbox;
+
+        if ( (gserialized_datum_get_gbox_p(gsdatum, &gbox) == LW_SUCCESS) &&
+         (box2df_from_gbox_p(&gbox, box2df) == LW_SUCCESS) )
+        {
+                return LW_SUCCESS;
+        }
+        return LW_FAILURE;
+}       
 
 

spike/pramsey/doublebox/postgis/gserialized_gist_nd.c

@@ -400 +400 @@
 gserialized_expand(GSERIALIZED *g, double distance)
 {
-        char boxmem[GIDX_MAX_SIZE];
-        GIDX *gidx = (GIDX*)boxmem;
-        float fdistance = (float)distance;
+        GBOX gbox;
 
         /* Get our bounding box out of the geography, return right away if
            input is an EMPTY geometry. */
-        if ( gserialized_get_gidx_p(g, gidx) == LW_FAILURE )
+        if ( gserialized_get_gbox_p(g, &gbox) == LW_FAILURE )
         {
                 return g;
         }
         
-        gidx_expand(gidx, fdistance);
-
-        return gserialized_set_gidx(g, gidx);
+        gbox_expand(&gbox, distance);
+
+        return gserialized_set_gbox(g, &gbox);
 }
 
@@ -422 +420 @@
 /*
 ** '~' and operator function. Based on two serialized return true if
-** the first is contained by the second.
+** the second is contained by the first.
 */
 PG_FUNCTION_INFO_V1(gserialized_within);

spike/pramsey/doublebox/postgis/lwgeom_functions_basic.c

@@ -2044 +2044 @@
         /* Pull only a small amount of the tuple, enough to get the type. */
         /* header + srid/flags + bbox? + type number */
-        size = VARHDRSZ + 8 + 32 + 4;  
+        size = VARHDRSZ + 8 + 64 + 4;  
 
         geom = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(PG_GETARG_DATUM(0), 0, size);

spike/pramsey/doublebox/postgis/lwgeom_inout.c

@@ -390 +390 @@
         lwgeom_add_bbox(lwgeom);
         result = geometry_serialize(lwgeom);
+        lwgeom_free(lwgeom);
         
         PG_FREE_IF_COPY(geom, 0);
@@ -405 +406 @@
                 PG_RETURN_POINTER(geom);
         
-        PG_RETURN_POINTER(gserialized_drop_gidx(geom));
+        PG_RETURN_POINTER(gserialized_drop_gbox(geom));
 }
 

spike/pramsey/doublebox/regress/lwgeom_regress_expected

@@ -1 +1 @@
 BOX(0 0.1,11 12)
 BOX3D(0 0.1 -55,11 12 12)
-11184
-15824
-20464
-15824
-11184
+11200
+15848
+20496
+15848
+11200