Datum RASTER_notSameAlignmentReason(PG_FUNCTION_ARGS)
{
const int set_count = 2;
rt_pgraster *pgrast[2];
int pgrastpos[2] = {-1, -1};
rt_raster rast[2] = {NULL};
uint32_t i;
uint32_t j;
uint32_t k;
int rtn;
int aligned = 0;
char *reason = NULL;
text *result = NULL;
for (i = 0, j = 0; i < set_count; i++) {
/* pgrast is null, return null */
if (PG_ARGISNULL(j)) {
for (k = 0; k < i; k++) {
rt_raster_destroy(rast[k]);
PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
PG_RETURN_NULL();
}
pgrast[i] = (rt_pgraster *) PG_DETOAST_DATUM_SLICE(PG_GETARG_DATUM(j), 0, sizeof(struct rt_raster_serialized_t));
pgrastpos[i] = j;
j++;
/* raster */
rast[i] = rt_raster_deserialize(pgrast[i], TRUE);
if (!rast[i]) {
for (k = 0; k <= i; k++) {
if (k < i)
rt_raster_destroy(rast[k]);
PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
elog(ERROR, "RASTER_notSameAlignmentReason: Could not deserialize the %s raster", i < 1 ? "first" : "second");
PG_RETURN_NULL();
}
}
rtn = rt_raster_same_alignment(
rast[0],
rast[1],
&aligned,
&reason
);
for (k = 0; k < set_count; k++) {
rt_raster_destroy(rast[k]);
PG_FREE_IF_COPY(pgrast[k], pgrastpos[k]);
}
if (rtn != ES_NONE) {
elog(ERROR, "RASTER_notSameAlignmentReason: Could not test for alignment on the two rasters");
PG_RETURN_NULL();
}
result = cstring2text(reason);
PG_RETURN_TEXT_P(result);
}
/**
* Peak into a #GSERIALIZED datum to find the bounding box. If the
* box is there, copy it out and return it. If not, calculate the box from the
* full object and return the box based on that. If no box is available,
* return #LW_FAILURE, otherwise #LW_SUCCESS.
*/
int
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! */
size_t size = gbox_serialized_size(gpart->flags);
POSTGIS_DEBUG(4, "copying box out of serialization");
memcpy(gidx->c, gpart->data, size);
/* if M is present but Z is not, pad Z and shift M */
if ( FLAGS_GET_M(gpart->flags) && ! FLAGS_GET_Z(gpart->flags) )
{
size += 2 * sizeof(float);
GIDX_SET_MIN(gidx,3,GIDX_GET_MIN(gidx,2));
GIDX_SET_MAX(gidx,3,GIDX_GET_MAX(gidx,2));
GIDX_SET_MIN(gidx,2,-1*FLT_MAX);
GIDX_SET_MAX(gidx,2,FLT_MAX);
}
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;
}
static uint8_t
gserialized_datum_get_flags(Datum gsdatum)
{
GSERIALIZED *gpart;
POSTGIS_DEBUG(4, "entered function");
gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(gsdatum, 0, 40);
POSTGIS_DEBUGF(4, "got flags %d", gpart->flags);
return gpart->flags;
}
uint32 pcid_from_datum(Datum d)
{
SERIALIZED_POINT *serpart;
if ( ! d )
return 0;
/* Serializations are int32_t <size> uint32_t <pcid> == 8 bytes */
/* Cast to SERIALIZED_POINT for convenience, SERIALIZED_PATCH shares same header */
serpart = (SERIALIZED_POINT*)PG_DETOAST_DATUM_SLICE(d, 0, 8);
return serpart->pcid;
}
/**
* Peak into a #GSERIALIZED datum to find the bounding box. If the
* box is there, copy it out and return it. If not, calculate the box from the
* full object and return the box based on that. If no box is available,
* return #LW_FAILURE, otherwise #LW_SUCCESS.
*/
static int
gserialized_datum_get_box2df_p(Datum gsdatum, BOX2DF *box2df)
{
GSERIALIZED *gpart;
uint8_t flags;
int result = 0;
/*
** The most info we need is the 8 bytes of serialized header plus the
** of floats necessary to hold the bounding box.
*/
if (VARATT_IS_EXTENDED(gsdatum))
{
gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(gsdatum, 0, 8 + sizeof(BOX2DF));
}
else
{
gpart = (GSERIALIZED*)PG_DETOAST_DATUM(gsdatum);
}
flags = gpart->flags;
/* Do we even have a serialized bounding box? */
if ( FLAGS_GET_BBOX(flags) )
{
/* Yes! Copy it out into the box! */
memcpy(box2df, gpart->data, sizeof(BOX2DF));
result = 1;
}
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);
}
printf("BOX2DF(%f %f, %f %f)\n", box2df->xmin, box2df->ymin, box2df->xmax, box2df->ymax);
return result;
}
/**
* Peak into a #GSERIALIZED datum to find the bounding box. If the
* box is there, copy it out and return it. If not, calculate the box from the
* full object and return the box based on that. If no box is available,
* return #LW_FAILURE, otherwise #LW_SUCCESS.
*/
static int
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;
}
/*
** Peak into a geography (gserialized) datum 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 G_FAILURE, otherwise G_SUCCESS.
*/
int geography_datum_gidx(Datum geography_datum, GIDX *gidx)
{
GSERIALIZED *gpart;
int result = G_SUCCESS;
POSTGIS_DEBUG(4, "entered function");
/*
** The most info we need is the 8 bytes of serialized header plus the 24 bytes
** of floats necessary to hold the 6 floats of the geocentric index
** bounding box, so 32 bytes.
*/
gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(geography_datum, 0, 32);
POSTGIS_DEBUGF(4, "got flags %d", gpart->flags);
if ( FLAGS_GET_BBOX(gpart->flags) && FLAGS_GET_GEODETIC(gpart->flags) )
{
const size_t size = 2 * 3 * sizeof(float);
POSTGIS_DEBUG(4, "copying box out of serialization");
memcpy(gidx->c, gpart->data, size);
SET_VARSIZE(gidx, VARHDRSZ + size);
}
else
{
GSERIALIZED *g = (GSERIALIZED*)PG_DETOAST_DATUM(geography_datum);
GBOX gbox;
POSTGIS_DEBUG(4, "calculating new box from scratch");
if ( gserialized_calculate_gbox_geocentric_p(g, &gbox) == G_FAILURE )
{
POSTGIS_DEBUG(4, "calculated null bbox, returning null");
return G_FAILURE;
}
result = gidx_from_gbox_p(gbox, gidx);
}
if ( result == G_SUCCESS )
{
POSTGIS_DEBUGF(4, "got gidx %s", gidx_to_string(gidx));
}
return result;
}
char *WTBtree_convertGeoHash(GISTENTRY *entry, int size)
{
char *minPnt, *maxPnt, *cvtGeoHash;
BOX2DF *box2df;
box2df = (BOX2DF *) palloc(sizeof(BOX2DF));
GSERIALIZED *gpart;
uint8_t flags;
if (VARATT_IS_EXTENDED(entry->key))
{
printf("true\n");
gpart = (GSERIALIZED*)PG_DETOAST_DATUM_SLICE(entry->key, 0, 8 + sizeof(BOX2DF));
printf("gpart->size : %d\n", gpart->size);
printf("gpart->flags : %d\n", gpart->flags);
flags = gpart->flags;
}
else
{
printf("false\n");
// gpart = (GSERIALIZED*)PG_DETOAST_DATUM(gsdatum);
}
if ( FLAGS_GET_BBOX(flags) )
{
printf("IsFlags : %d\n", flags);
memcpy(box2df, gpart->data, sizeof(BOX2DF));
//result = LW_SUCCESS;
printf("----------------: %f\n", box2df->xmin);
printf("----------------: %f\n", box2df->ymin);
printf("----------------: %f\n", box2df->xmax);
printf("----------------: %f\n", box2df->ymax);
minPnt = (char*) palloc(size);
maxPnt = (char*) palloc(size);
cvtGeoHash = (char*) palloc(size);
memcpy(minPnt, geohash_encode((double) box2df->ymin, (double) box2df->xmin, size), size);
memcpy(maxPnt, geohash_encode((double) box2df->ymax, (double) box2df->xmax, size), size);
cvtGeoHash = convert_GeoHash_from_box2d(minPnt, maxPnt, size);
printf("-----------geohash_encode : %s\n", cvtGeoHash);
}
else
{
printf("NotFlags : %d\n", flags);
/*
GBOX gbox;
GSERIALIZED *g = (GSERIALIZED*)PG_DETOAST_DATUM(entry->key);
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);
*/
}
return cvtGeoHash;
}
