* that we don't yet have as infinity.
*
* Portions Copyright (c) 2018, Esteban Zimanyi, Arthur Lesuisse,
- * Université Libre de Bruxelles
+ * Université Libre de Bruxelles
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*****************************************************************************/
#include <postgres.h>
-#include <utils/builtins.h> /* For float manipulation */
-#include "access/spgist.h" /* For SP-GiST */
-#include "catalog/namespace.h" /* For TypenameGetTypid */
-#include "catalog/pg_type_d.h" /* For VOIDOID */
+#include <utils/builtins.h> /* For float manipulation */
+#include "access/spgist.h" /* For SP-GiST */
+#include "catalog/namespace.h" /* For TypenameGetTypid */
+#include "catalog/pg_type_d.h" /* For VOIDOID */
#include "../postgis_config.h"
-#include "liblwgeom.h" /* For standard geometry types. */
-#include "lwgeom_pg.h" /* For debugging macros. */
-#include <gserialized_gist.h> /* For utility functions. */
-#include <lwgeom_pg.h> /* For debugging macros. */
+#include "liblwgeom.h" /* For standard geometry types. */
+#include "lwgeom_pg.h" /* For debugging macros. */
+#include <gserialized_gist.h> /* For utility functions. */
+#include <lwgeom_pg.h> /* For debugging macros. */
/*
** SP-GiST 2D index function prototypes
static int
compareDoubles(const void *a, const void *b)
{
- double x = *(double *) a;
- double y = *(double *) b;
+ double x = *(double *)a;
+ double y = *(double *)b;
if (x == y)
return 0;
typedef struct
{
- BOX2DF left;
- BOX2DF right;
+ BOX2DF left;
+ BOX2DF right;
} RectBox;
/*
static uint8
getQuadrant4D(BOX2DF *centroid, BOX2DF *inBox)
{
- uint8 quadrant = 0;
+ uint8 quadrant = 0;
if (inBox->xmin > centroid->xmin)
quadrant |= 0x8;
static RectBox *
initRectBox(void)
{
- RectBox *rect_box = (RectBox *) palloc(sizeof(RectBox));
- float infinity = get_float4_infinity();
+ RectBox *rect_box = (RectBox *)palloc(sizeof(RectBox));
+ float infinity = get_float4_infinity();
rect_box->left.xmin = -infinity;
rect_box->left.xmax = infinity;
static RectBox *
nextRectBox(RectBox *rect_box, BOX2DF *centroid, uint8 quadrant)
{
- RectBox *next_rect_box = (RectBox *) palloc(sizeof(RectBox));
+ RectBox *next_rect_box = (RectBox *)palloc(sizeof(RectBox));
memcpy(next_rect_box, rect_box, sizeof(RectBox));
static bool
overlap4D(RectBox *rect_box, BOX2DF *query)
{
- return (rect_box->left.xmin <= query->xmax &&
- rect_box->right.xmax >= query->xmin &&
- rect_box->left.ymin <= query->ymax &&
- rect_box->right.ymax >= query->ymin);
+ return (rect_box->left.xmin <= query->xmax && rect_box->right.xmax >= query->xmin) &&
+ (rect_box->left.ymin <= query->ymax && rect_box->right.ymax >= query->ymin);
}
/* Can any cube from rect_box contain query? */
static bool
contain4D(RectBox *rect_box, BOX2DF *query)
{
- return (rect_box->right.xmax >= query->xmax &&
- rect_box->left.xmin <= query->xmin &&
- rect_box->right.ymax >= query->ymax &&
- rect_box->left.ymin <= query->ymin);
+ return (rect_box->right.xmax >= query->xmax && rect_box->left.xmin <= query->xmin) &&
+ (rect_box->right.ymax >= query->ymax && rect_box->left.ymin <= query->ymin);
}
/* Can any cube from rect_box be left of query? */
PG_FUNCTION_INFO_V1(gserialized_spgist_config_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_config_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_config_2d(PG_FUNCTION_ARGS)
{
- spgConfigOut *cfg = (spgConfigOut *) PG_GETARG_POINTER(1);
+ spgConfigOut *cfg = (spgConfigOut *)PG_GETARG_POINTER(1);
Oid boxoid = TypenameGetTypid("box2df");
cfg->prefixType = boxoid;
- cfg->labelType = VOIDOID; /* We don't need node labels. */
+ cfg->labelType = VOIDOID; /* We don't need node labels. */
cfg->leafType = boxoid;
cfg->canReturnData = false;
cfg->longValuesOK = false;
PG_FUNCTION_INFO_V1(gserialized_spgist_choose_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_choose_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_choose_2d(PG_FUNCTION_ARGS)
{
- spgChooseIn *in = (spgChooseIn *) PG_GETARG_POINTER(0);
- spgChooseOut *out = (spgChooseOut *) PG_GETARG_POINTER(1);
- BOX2DF *centroid = (BOX2DF *) DatumGetPointer(in->prefixDatum),
- *box = (BOX2DF *) DatumGetPointer(in->leafDatum);
+ spgChooseIn *in = (spgChooseIn *)PG_GETARG_POINTER(0);
+ spgChooseOut *out = (spgChooseOut *)PG_GETARG_POINTER(1);
+ BOX2DF *centroid = (BOX2DF *)DatumGetPointer(in->prefixDatum), *box = (BOX2DF *)DatumGetPointer(in->leafDatum);
out->resultType = spgMatchNode;
out->result.matchNode.restDatum = PointerGetDatum(box);
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_picksplit_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_picksplit_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_picksplit_2d(PG_FUNCTION_ARGS)
{
- spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
- spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
- BOX2DF *centroid;
- int median,
- i;
- double *lowXs = palloc(sizeof(double) * in->nTuples);
- double *highXs = palloc(sizeof(double) * in->nTuples);
- double *lowYs = palloc(sizeof(double) * in->nTuples);
- double *highYs = palloc(sizeof(double) * in->nTuples);
+ spgPickSplitIn *in = (spgPickSplitIn *)PG_GETARG_POINTER(0);
+ spgPickSplitOut *out = (spgPickSplitOut *)PG_GETARG_POINTER(1);
+ BOX2DF *centroid;
+ int median, i;
+ double *lowXs = palloc(sizeof(double) * in->nTuples);
+ double *highXs = palloc(sizeof(double) * in->nTuples);
+ double *lowYs = palloc(sizeof(double) * in->nTuples);
+ double *highYs = palloc(sizeof(double) * in->nTuples);
/* Calculate median of all 4D coordinates */
for (i = 0; i < in->nTuples; i++)
{
- BOX2DF *box = (BOX2DF *) DatumGetPointer(in->datums[i]);
+ BOX2DF *box = (BOX2DF *)DatumGetPointer(in->datums[i]);
- lowXs[i] = (double) box->xmin;
- highXs[i] = (double) box->xmax;
- lowYs[i] = (double) box->ymin;
- highYs[i] = (double) box->ymax;
+ lowXs[i] = (double)box->xmin;
+ highXs[i] = (double)box->xmax;
+ lowYs[i] = (double)box->ymin;
+ highYs[i] = (double)box->ymax;
}
qsort(lowXs, in->nTuples, sizeof(double), compareDoubles);
centroid = palloc(sizeof(BOX2DF));
- centroid->xmin = (float) lowXs[median];
- centroid->xmax = (float) highXs[median];
- centroid->ymin = (float) lowYs[median];
- centroid->ymax = (float) highYs[median];
+ centroid->xmin = (float)lowXs[median];
+ centroid->xmax = (float)highXs[median];
+ centroid->ymin = (float)lowYs[median];
+ centroid->ymax = (float)highYs[median];
/* Fill the output */
out->hasPrefix = true;
out->prefixDatum = BoxPGetDatum(centroid);
out->nNodes = 16;
- out->nodeLabels = NULL; /* We don't need node labels. */
+ out->nodeLabels = NULL; /* We don't need node labels. */
out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
/*
- * Assign ranges to corresponding nodes according to quadrants relative to
- * the "centroid" range
+ * Assign ranges to corresponding nodes according to quadrants relative to the "centroid" range
*/
for (i = 0; i < in->nTuples; i++)
{
- BOX2DF *box = (BOX2DF *) DatumGetPointer(in->datums[i]);
- uint8 quadrant = getQuadrant4D(centroid, box);
+ BOX2DF *box = (BOX2DF *)DatumGetPointer(in->datums[i]);
+ uint8 quadrant = getQuadrant4D(centroid, box);
out->leafTupleDatums[i] = PointerGetDatum(box);
out->mapTuplesToNodes[i] = quadrant;
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_inner_consistent_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_inner_consistent_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_inner_consistent_2d(PG_FUNCTION_ARGS)
{
- spgInnerConsistentIn *in = (spgInnerConsistentIn *) PG_GETARG_POINTER(0);
- spgInnerConsistentOut *out = (spgInnerConsistentOut *) PG_GETARG_POINTER(1);
- int i;
+ spgInnerConsistentIn *in = (spgInnerConsistentIn *)PG_GETARG_POINTER(0);
+ spgInnerConsistentOut *out = (spgInnerConsistentOut *)PG_GETARG_POINTER(1);
+ int i;
MemoryContext old_ctx;
- RectBox *rect_box;
- uint8 quadrant;
- BOX2DF *centroid;
+ RectBox *rect_box;
+ uint8 quadrant;
+ BOX2DF *centroid;
if (in->allTheSame)
{
/* Report that all nodes should be visited */
out->nNodes = in->nNodes;
- out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
+ out->nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
for (i = 0; i < in->nNodes; i++)
out->nodeNumbers[i] = i;
else
rect_box = initRectBox();
- centroid = (BOX2DF *) DatumGetPointer(in->prefixDatum);
+ centroid = (BOX2DF *)DatumGetPointer(in->prefixDatum);
/* Allocate enough memory for nodes */
out->nNodes = 0;
- out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
- out->traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
+ out->nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
+ out->traversalValues = (void **)palloc(sizeof(void *) * in->nNodes);
/*
* We switch memory context, because we want to allocate memory for new
for (quadrant = 0; quadrant < in->nNodes; quadrant++)
{
- RectBox *next_rect_box = nextRectBox(rect_box, centroid, quadrant);
- bool flag = true;
+ RectBox *next_rect_box = nextRectBox(rect_box, centroid, quadrant);
+ bool flag = true;
for (i = 0; i < in->nkeys; i++)
{
StrategyNumber strategy = in->scankeys[i].sk_strategy;
- Datum query = in->scankeys[i].sk_argument;
- BOX2DF query_gbox_index;
+ Datum query = in->scankeys[i].sk_argument;
+ BOX2DF query_gbox_index;
/* Quick sanity check on query argument. */
- if ( DatumGetPointer(query) == NULL )
+ if (DatumGetPointer(query) == NULL)
{
POSTGIS_DEBUG(4, "[SPGIST] null query pointer (!?!), returning false");
PG_RETURN_BOOL(false); /* NULL query! This is screwy! */
}
- if ( gserialized_datum_get_box2df_p(query, &query_gbox_index) == LW_FAILURE )
+ if (gserialized_datum_get_box2df_p(query, &query_gbox_index) == LW_FAILURE)
{
POSTGIS_DEBUG(4, "[SPGIST] null query_gbox_index!");
PG_RETURN_BOOL(false);
switch (strategy)
{
- case RTOverlapStrategyNumber:
- case RTContainedByStrategyNumber:
- case RTOldContainedByStrategyNumber:
- flag = overlap4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTContainsStrategyNumber:
- case RTSameStrategyNumber:
- flag = contain4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTLeftStrategyNumber:
- flag = !overRight4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTOverLeftStrategyNumber:
- flag = !right4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTRightStrategyNumber:
- flag = !overLeft4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTOverRightStrategyNumber:
- flag = !left4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTAboveStrategyNumber:
- flag = !overBelow4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTOverAboveStrategyNumber:
- flag = !below4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTBelowStrategyNumber:
- flag = !overAbove4D(next_rect_box, &query_gbox_index);
- break;
-
- case RTOverBelowStrategyNumber:
- flag = !above4D(next_rect_box, &query_gbox_index);
- break;
-
- default:
- elog(ERROR, "unrecognized strategy: %d", strategy);
+ case RTOverlapStrategyNumber:
+ case RTContainedByStrategyNumber:
+ case RTOldContainedByStrategyNumber:
+ flag = overlap4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTContainsStrategyNumber:
+ case RTSameStrategyNumber:
+ flag = contain4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTLeftStrategyNumber:
+ flag = !overRight4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTOverLeftStrategyNumber:
+ flag = !right4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTRightStrategyNumber:
+ flag = !overLeft4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTOverRightStrategyNumber:
+ flag = !left4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTAboveStrategyNumber:
+ flag = !overBelow4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTOverAboveStrategyNumber:
+ flag = !below4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTBelowStrategyNumber:
+ flag = !overAbove4D(next_rect_box, &query_gbox_index);
+ break;
+
+ case RTOverBelowStrategyNumber:
+ flag = !above4D(next_rect_box, &query_gbox_index);
+ break;
+
+ default:
+ elog(ERROR, "unrecognized strategy: %d", strategy);
}
/* If any check is failed, we have found our answer. */
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_leaf_consistent_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_leaf_consistent_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_leaf_consistent_2d(PG_FUNCTION_ARGS)
{
- spgLeafConsistentIn *in = (spgLeafConsistentIn *) PG_GETARG_POINTER(0);
- spgLeafConsistentOut *out = (spgLeafConsistentOut *) PG_GETARG_POINTER(1);
- BOX2DF *key = (BOX2DF *) DatumGetPointer(in->leafDatum);
- bool flag = true;
- int i;
+ spgLeafConsistentIn *in = (spgLeafConsistentIn *)PG_GETARG_POINTER(0);
+ spgLeafConsistentOut *out = (spgLeafConsistentOut *)PG_GETARG_POINTER(1);
+ BOX2DF *key = (BOX2DF *)DatumGetPointer(in->leafDatum);
+ bool flag = true;
+ int i;
/* Quick sanity check on entry key. */
- if ( DatumGetPointer(key) == NULL )
+ if (DatumGetPointer(key) == NULL)
{
POSTGIS_DEBUG(4, "[SPGIST] null index entry, returning false");
PG_RETURN_BOOL(false); /* NULL entry! */
for (i = 0; i < in->nkeys; i++)
{
StrategyNumber strategy = in->scankeys[i].sk_strategy;
- Datum query = in->scankeys[i].sk_argument;
- BOX2DF query_gbox_index;
+ Datum query = in->scankeys[i].sk_argument;
+ BOX2DF query_gbox_index;
/* Quick sanity check on query argument. */
- if ( DatumGetPointer(query) == NULL )
+ if (DatumGetPointer(query) == NULL)
{
POSTGIS_DEBUG(4, "[SPGIST] null query pointer (!?!), returning false");
PG_RETURN_BOOL(false); /* NULL query! This is screwy! */
}
- if ( gserialized_datum_get_box2df_p(query, &query_gbox_index) == LW_FAILURE )
+ if (gserialized_datum_get_box2df_p(query, &query_gbox_index) == LW_FAILURE)
{
POSTGIS_DEBUG(4, "[SPGIST] null query_gbox_index!");
PG_RETURN_BOOL(false);
switch (strategy)
{
- case RTOverlapStrategyNumber:
- flag = box2df_overlaps(key, &query_gbox_index);
- break;
+ case RTOverlapStrategyNumber:
+ flag = box2df_overlaps(key, &query_gbox_index);
+ break;
- case RTContainsStrategyNumber:
- case RTOldContainsStrategyNumber:
- flag = box2df_contains(key, &query_gbox_index);
- break;
+ case RTContainsStrategyNumber:
+ case RTOldContainsStrategyNumber:
+ flag = box2df_contains(key, &query_gbox_index);
+ break;
- case RTContainedByStrategyNumber:
- case RTOldContainedByStrategyNumber:
- flag = box2df_contains(&query_gbox_index, key);
- break;
+ case RTContainedByStrategyNumber:
+ case RTOldContainedByStrategyNumber:
+ flag = box2df_contains(&query_gbox_index, key);
+ break;
- case RTSameStrategyNumber:
- flag = box2df_equals(key, &query_gbox_index);
- break;
+ case RTSameStrategyNumber:
+ flag = box2df_equals(key, &query_gbox_index);
+ break;
- case RTLeftStrategyNumber:
- flag = box2df_left(key, &query_gbox_index);
- break;
+ case RTLeftStrategyNumber:
+ flag = box2df_left(key, &query_gbox_index);
+ break;
- case RTOverLeftStrategyNumber:
- flag = box2df_overleft(key, &query_gbox_index);
- break;
+ case RTOverLeftStrategyNumber:
+ flag = box2df_overleft(key, &query_gbox_index);
+ break;
- case RTRightStrategyNumber:
- flag = box2df_right(key, &query_gbox_index);
- break;
+ case RTRightStrategyNumber:
+ flag = box2df_right(key, &query_gbox_index);
+ break;
- case RTOverRightStrategyNumber:
- flag = box2df_overright(key, &query_gbox_index);
- break;
+ case RTOverRightStrategyNumber:
+ flag = box2df_overright(key, &query_gbox_index);
+ break;
- case RTAboveStrategyNumber:
- flag = box2df_above(key, &query_gbox_index);
- break;
+ case RTAboveStrategyNumber:
+ flag = box2df_above(key, &query_gbox_index);
+ break;
- case RTOverAboveStrategyNumber:
- flag = box2df_overabove(key, &query_gbox_index);
- break;
+ case RTOverAboveStrategyNumber:
+ flag = box2df_overabove(key, &query_gbox_index);
+ break;
- case RTBelowStrategyNumber:
- flag = box2df_below(key, &query_gbox_index);
- break;
+ case RTBelowStrategyNumber:
+ flag = box2df_below(key, &query_gbox_index);
+ break;
- case RTOverBelowStrategyNumber:
- flag = box2df_overbelow(key, &query_gbox_index);
- break;
+ case RTOverBelowStrategyNumber:
+ flag = box2df_overbelow(key, &query_gbox_index);
+ break;
- default:
- elog(ERROR, "unrecognized strategy: %d", strategy);
+ default:
+ elog(ERROR, "unrecognized strategy: %d", strategy);
}
/* If any check is failed, we have found our answer. */
PG_RETURN_BOOL(flag);
}
-/*
-** RTiST support function. Given a geography, return a "compressed"
-** version. In this case, we convert the geography into a geocentric
-** bounding box. If the geography already has the box embedded in it
-** we pull that out and hand it back.
-*/
-
PG_FUNCTION_INFO_V1(gserialized_spgist_compress_2d);
-PGDLLEXPORT Datum
-gserialized_spgist_compress_2d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_compress_2d(PG_FUNCTION_ARGS)
{
- Datum gsdatum = PG_GETARG_DATUM(0);
- BOX2DF *bbox_out = palloc(sizeof(BOX2DF));
+ Datum gsdatum = PG_GETARG_DATUM(0);
+ BOX2DF *bbox_out = palloc(sizeof(BOX2DF));
int result = LW_SUCCESS;
POSTGIS_DEBUG(4, "[SPGIST] 'compress' function called");
result = gserialized_datum_get_box2df_p(gsdatum, bbox_out);
/* Is the bounding box valid (non-empty, non-infinite)? If not, return input uncompressed. */
- if ( result == LW_FAILURE )
+ if (result == LW_FAILURE)
{
box2df_set_empty(bbox_out);
POSTGIS_DEBUGF(4, "[SPGIST] got box: %s", box2df_to_string(bbox_out));
/* Check all the dimensions for finite values */
- if ( ! isfinite(bbox_out->xmax) || ! isfinite(bbox_out->xmin) ||
- ! isfinite(bbox_out->ymax) || ! isfinite(bbox_out->ymin) )
+ if ((!isfinite(bbox_out->xmax) || !isfinite(bbox_out->xmin)) ||
+ (!isfinite(bbox_out->ymax) || !isfinite(bbox_out->ymin)))
{
box2df_set_finite(bbox_out);
*****************************************************************************/
#include "gserialized_spgist_3d.h"
+#include "lwgeom_box3d.h"
#include "lwgeom_pg.h"
PG_FUNCTION_INFO_V1(gserialized_overlaps_3d);
BOX3D *box1 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
BOX3D *box2 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(1)));
bool resut = BOX3D_overlaps_internal(box1, box2);
- pfree(box1); pfree(box2);
+ pfree(box1);
+ pfree(box2);
PG_RETURN_BOOL(resut);
}
BOX3D *box1 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
BOX3D *box2 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(1)));
bool resut = BOX3D_contains_internal(box1, box2);
- pfree(box1); pfree(box2);
+ pfree(box1);
+ pfree(box2);
PG_RETURN_BOOL(resut);
}
BOX3D *box1 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
BOX3D *box2 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(1)));
bool resut = BOX3D_contained_internal(box1, box2);
- pfree(box1); pfree(box2);
+ pfree(box1);
+ pfree(box2);
PG_RETURN_BOOL(resut);
}
BOX3D *box1 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
BOX3D *box2 = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(1)));
bool resut = BOX3D_same_internal(box1, box2);
- pfree(box1); pfree(box2);
+ pfree(box1);
+ pfree(box2);
PG_RETURN_BOOL(resut);
}
static int
compareDoubles(const void *a, const void *b)
{
- double x = *(double *) a;
- double y = *(double *) b;
+ double x = *(double *)a;
+ double y = *(double *)b;
if (x == y)
return 0;
typedef struct
{
- BOX3D left;
- BOX3D right;
+ BOX3D left;
+ BOX3D right;
} CubeBox3D;
/*
static uint8
getOctant(BOX3D *centroid, BOX3D *inBox)
{
- uint8 octant = 0;
+ uint8 octant = 0;
if (inBox->xmin > centroid->xmin)
octant |= 0x20;
static CubeBox3D *
initCubeBox(void)
{
- CubeBox3D *cube_box = (CubeBox3D *) palloc(sizeof(CubeBox3D));
- double infinity = get_float8_infinity();
+ CubeBox3D *cube_box = (CubeBox3D *)palloc(sizeof(CubeBox3D));
+ double infinity = get_float8_infinity();
cube_box->left.xmin = -infinity;
cube_box->left.xmax = infinity;
/*
* Calculate the next traversal value
*
- * All centroids are bounded by CubeBox3D, but SP-GiST only keeps
- * boxes. When we are traversing the tree, we must calculate CubeBox3D,
+ * All centroids are bounded by CubeBox3D, but SP-GiST only keeps boxes.
+ * When we are traversing the tree, we must calculate CubeBox3D,
* using centroid and octant.
*/
static CubeBox3D *
nextCubeBox3D(CubeBox3D *cube_box, BOX3D *centroid, uint8 octant)
{
- CubeBox3D *next_cube_box = (CubeBox3D *) palloc(sizeof(CubeBox3D));
+ CubeBox3D *next_cube_box = (CubeBox3D *)palloc(sizeof(CubeBox3D));
memcpy(next_cube_box, cube_box, sizeof(CubeBox3D));
static bool
overlap6D(CubeBox3D *cube_box, BOX3D *query)
{
- return (cube_box->left.xmin <= query->xmax) &&
- (cube_box->right.xmax >= query->xmin) &&
- (cube_box->left.ymin <= query->ymax) &&
- (cube_box->right.ymax >= query->ymin) &&
- (cube_box->left.zmin <= query->zmax) &&
- (cube_box->right.zmax >= query->zmin);
+ return (cube_box->left.xmin <= query->xmax) && (cube_box->right.xmax >= query->xmin) &&
+ (cube_box->left.ymin <= query->ymax) && (cube_box->right.ymax >= query->ymin) &&
+ (cube_box->left.zmin <= query->zmax) && (cube_box->right.zmax >= query->zmin);
}
/* Can any cube from cube_box contain query? */
static bool
contain6D(CubeBox3D *cube_box, BOX3D *query)
{
- return (cube_box->right.xmax >= query->xmax) &&
- (cube_box->left.xmin <= query->xmin) &&
- (cube_box->right.ymax >= query->ymax) &&
- (cube_box->left.ymin <= query->ymin) &&
- (cube_box->right.zmax >= query->zmax) &&
- (cube_box->left.zmin <= query->zmin);
+ return (cube_box->right.xmax >= query->xmax) && (cube_box->left.xmin <= query->xmin) &&
+ (cube_box->right.ymax >= query->ymax) && (cube_box->left.ymin <= query->ymin) &&
+ (cube_box->right.zmax >= query->zmax) && (cube_box->left.zmin <= query->zmin);
}
/* Can any cube from cube_box be left of query? */
PG_FUNCTION_INFO_V1(gserialized_spgist_config_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_config_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_config_3d(PG_FUNCTION_ARGS)
{
- spgConfigOut *cfg = (spgConfigOut *) PG_GETARG_POINTER(1);
+ spgConfigOut *cfg = (spgConfigOut *)PG_GETARG_POINTER(1);
Oid boxoid = TypenameGetTypid("box3d");
cfg->prefixType = boxoid;
- cfg->labelType = VOIDOID; /* We don't need node labels. */
+ cfg->labelType = VOIDOID; /* We don't need node labels. */
cfg->leafType = boxoid;
cfg->canReturnData = false;
cfg->longValuesOK = false;
PG_FUNCTION_INFO_V1(gserialized_spgist_choose_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_choose_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_choose_3d(PG_FUNCTION_ARGS)
{
- spgChooseIn *in = (spgChooseIn *) PG_GETARG_POINTER(0);
- spgChooseOut *out = (spgChooseOut *) PG_GETARG_POINTER(1);
- BOX3D *centroid = DatumGetBox3DP(in->prefixDatum),
- *box = DatumGetBox3DP(in->leafDatum);
+ spgChooseIn *in = (spgChooseIn *)PG_GETARG_POINTER(0);
+ spgChooseOut *out = (spgChooseOut *)PG_GETARG_POINTER(1);
+ BOX3D *centroid = DatumGetBox3DP(in->prefixDatum);
+ BOX3D *box = DatumGetBox3DP(in->leafDatum);
out->resultType = spgMatchNode;
out->result.matchNode.restDatum = Box3DPGetDatum(box);
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_picksplit_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_picksplit_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_picksplit_3d(PG_FUNCTION_ARGS)
{
- spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
- spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
- BOX3D *centroid;
- int median,
- i;
- double *lowXs = palloc(sizeof(double) * in->nTuples);
- double *highXs = palloc(sizeof(double) * in->nTuples);
- double *lowYs = palloc(sizeof(double) * in->nTuples);
- double *highYs = palloc(sizeof(double) * in->nTuples);
- double *lowZs = palloc(sizeof(double) * in->nTuples);
- double *highZs = palloc(sizeof(double) * in->nTuples);
- BOX3D *box = DatumGetBox3DP(in->datums[0]);
- int32_t srid = box->srid;
+ spgPickSplitIn *in = (spgPickSplitIn *)PG_GETARG_POINTER(0);
+ spgPickSplitOut *out = (spgPickSplitOut *)PG_GETARG_POINTER(1);
+ BOX3D *centroid;
+ int median, i;
+ double *lowXs = palloc(sizeof(double) * in->nTuples);
+ double *highXs = palloc(sizeof(double) * in->nTuples);
+ double *lowYs = palloc(sizeof(double) * in->nTuples);
+ double *highYs = palloc(sizeof(double) * in->nTuples);
+ double *lowZs = palloc(sizeof(double) * in->nTuples);
+ double *highZs = palloc(sizeof(double) * in->nTuples);
+ BOX3D *box = DatumGetBox3DP(in->datums[0]);
+ int32_t srid = box->srid;
/* Calculate median of all 6D coordinates */
for (i = 0; i < in->nTuples; i++)
{
- BOX3D *box = DatumGetBox3DP(in->datums[i]);
+ BOX3D *box = DatumGetBox3DP(in->datums[i]);
lowXs[i] = box->xmin;
highXs[i] = box->xmax;
out->prefixDatum = Box3DPGetDatum(centroid);
out->nNodes = 64;
- out->nodeLabels = NULL; /* We don't need node labels. */
+ out->nodeLabels = NULL; /* We don't need node labels. */
out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
*/
for (i = 0; i < in->nTuples; i++)
{
- BOX3D *box = DatumGetBox3DP(in->datums[i]);
- uint8 octant = getOctant(centroid, box);
+ BOX3D *box = DatumGetBox3DP(in->datums[i]);
+ uint8 octant = getOctant(centroid, box);
out->leafTupleDatums[i] = Box3DPGetDatum(box);
out->mapTuplesToNodes[i] = octant;
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_inner_consistent_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_inner_consistent_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_inner_consistent_3d(PG_FUNCTION_ARGS)
{
- spgInnerConsistentIn *in = (spgInnerConsistentIn *) PG_GETARG_POINTER(0);
- spgInnerConsistentOut *out = (spgInnerConsistentOut *) PG_GETARG_POINTER(1);
- int i;
+ spgInnerConsistentIn *in = (spgInnerConsistentIn *)PG_GETARG_POINTER(0);
+ spgInnerConsistentOut *out = (spgInnerConsistentOut *)PG_GETARG_POINTER(1);
+ int i;
MemoryContext old_ctx;
- CubeBox3D *cube_box;
- uint8 octant;
- BOX3D *centroid;
- int *nodeNumbers;
- void **traversalValues;
+ CubeBox3D *cube_box;
+ uint8 octant;
+ BOX3D *centroid;
+ int *nodeNumbers;
+ void **traversalValues;
if (in->allTheSame)
{
/* Report that all nodes should be visited */
out->nNodes = in->nNodes;
- out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
+ out->nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
for (i = 0; i < in->nNodes; i++)
out->nodeNumbers[i] = i;
/* Allocate enough memory for nodes */
out->nNodes = 0;
- nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
- traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
+ nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
+ traversalValues = (void **)palloc(sizeof(void *) * in->nNodes);
/*
* We switch memory context, because we want to allocate memory for new
for (octant = 0; octant < in->nNodes; octant++)
{
- CubeBox3D *next_cube_box = nextCubeBox3D(cube_box, centroid, octant);
- bool flag = true;
+ CubeBox3D *next_cube_box = nextCubeBox3D(cube_box, centroid, octant);
+ bool flag = true;
for (i = 0; i < in->nkeys; i++)
{
StrategyNumber strategy = in->scankeys[i].sk_strategy;
- Datum query = in->scankeys[i].sk_argument;
- BOX3D *box = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, query));
+ Datum query = in->scankeys[i].sk_argument;
+ BOX3D *box = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, query));
switch (strategy)
{
- case SPGOverlapStrategyNumber:
- case SPGContainedByStrategyNumber:
- flag = overlap6D(next_cube_box, box);
- break;
-
- case SPGContainsStrategyNumber:
- case SPGSameStrategyNumber:
- flag = contain6D(next_cube_box, box);
- break;
-
- case SPGLeftStrategyNumber:
- flag = !overRight6D(next_cube_box, box);
- break;
-
- case SPGOverLeftStrategyNumber:
- flag = !right6D(next_cube_box, box);
- break;
-
- case SPGRightStrategyNumber:
- flag = !overLeft6D(next_cube_box, box);
- break;
-
- case SPGOverRightStrategyNumber:
- flag = !left6D(next_cube_box, box);
- break;
-
- case SPGAboveStrategyNumber:
- flag = !overBelow6D(next_cube_box, box);
- break;
-
- case SPGOverAboveStrategyNumber:
- flag = !below6D(next_cube_box, box);
- break;
-
- case SPGBelowStrategyNumber:
- flag = !overAbove6D(next_cube_box, box);
- break;
-
- case SPGOverBelowStrategyNumber:
- flag = !above6D(next_cube_box, box);
- break;
-
- case SPGBackStrategyNumber:
- flag = !overFront6D(next_cube_box, box);
- break;
-
- case SPGOverBackStrategyNumber:
- flag = !front6D(next_cube_box, box);
- break;
-
- case SPGFrontStrategyNumber:
- flag = !overBack6D(next_cube_box, box);
- break;
-
- case SPGOverFrontStrategyNumber:
- flag = !back6D(next_cube_box, box);
- break;
-
- default:
- elog(ERROR, "unrecognized strategy: %d", strategy);
+ case SPGOverlapStrategyNumber:
+ case SPGContainedByStrategyNumber:
+ flag = overlap6D(next_cube_box, box);
+ break;
+
+ case SPGContainsStrategyNumber:
+ case SPGSameStrategyNumber:
+ flag = contain6D(next_cube_box, box);
+ break;
+
+ case SPGLeftStrategyNumber:
+ flag = !overRight6D(next_cube_box, box);
+ break;
+
+ case SPGOverLeftStrategyNumber:
+ flag = !right6D(next_cube_box, box);
+ break;
+
+ case SPGRightStrategyNumber:
+ flag = !overLeft6D(next_cube_box, box);
+ break;
+
+ case SPGOverRightStrategyNumber:
+ flag = !left6D(next_cube_box, box);
+ break;
+
+ case SPGAboveStrategyNumber:
+ flag = !overBelow6D(next_cube_box, box);
+ break;
+
+ case SPGOverAboveStrategyNumber:
+ flag = !below6D(next_cube_box, box);
+ break;
+
+ case SPGBelowStrategyNumber:
+ flag = !overAbove6D(next_cube_box, box);
+ break;
+
+ case SPGOverBelowStrategyNumber:
+ flag = !above6D(next_cube_box, box);
+ break;
+
+ case SPGBackStrategyNumber:
+ flag = !overFront6D(next_cube_box, box);
+ break;
+
+ case SPGOverBackStrategyNumber:
+ flag = !front6D(next_cube_box, box);
+ break;
+
+ case SPGFrontStrategyNumber:
+ flag = !overBack6D(next_cube_box, box);
+ break;
+
+ case SPGOverFrontStrategyNumber:
+ flag = !back6D(next_cube_box, box);
+ break;
+
+ default:
+ elog(ERROR, "unrecognized strategy: %d", strategy);
}
/* If any check is failed, we have found our answer. */
}
/* Pass to the next level only the values that need to be traversed */
- out->nodeNumbers = (int *) palloc(sizeof(int) * out->nNodes);
- out->traversalValues = (void **) palloc(sizeof(void *) * out->nNodes);
+ out->nodeNumbers = (int *)palloc(sizeof(int) * out->nNodes);
+ out->traversalValues = (void **)palloc(sizeof(void *) * out->nNodes);
for (i = 0; i < out->nNodes; i++)
{
out->nodeNumbers[i] = nodeNumbers[i];
*/
PG_FUNCTION_INFO_V1(gserialized_spgist_leaf_consistent_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_leaf_consistent_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_leaf_consistent_3d(PG_FUNCTION_ARGS)
{
- spgLeafConsistentIn *in = (spgLeafConsistentIn *) PG_GETARG_POINTER(0);
- spgLeafConsistentOut *out = (spgLeafConsistentOut *) PG_GETARG_POINTER(1);
- BOX3D *leaf = DatumGetBox3DP(in->leafDatum);
- bool flag = true;
- int i;
+ spgLeafConsistentIn *in = (spgLeafConsistentIn *)PG_GETARG_POINTER(0);
+ spgLeafConsistentOut *out = (spgLeafConsistentOut *)PG_GETARG_POINTER(1);
+ BOX3D *leaf = DatumGetBox3DP(in->leafDatum);
+ bool flag = true;
+ int i;
/* All tests are exact. */
out->recheck = false;
for (i = 0; i < in->nkeys; i++)
{
StrategyNumber strategy = in->scankeys[i].sk_strategy;
- Datum query = in->scankeys[i].sk_argument;
- BOX3D *box = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, query));
+ Datum query = in->scankeys[i].sk_argument;
+ BOX3D *box = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, query));
switch (strategy)
{
- case SPGOverlapStrategyNumber:
- flag = BOX3D_overlaps_internal(leaf, box);
- break;
+ case SPGOverlapStrategyNumber:
+ flag = BOX3D_overlaps_internal(leaf, box);
+ break;
- case SPGContainsStrategyNumber:
- flag = BOX3D_contains_internal(leaf, box);
- break;
+ case SPGContainsStrategyNumber:
+ flag = BOX3D_contains_internal(leaf, box);
+ break;
- case SPGContainedByStrategyNumber:
- flag = BOX3D_contained_internal(leaf, box);
- break;
+ case SPGContainedByStrategyNumber:
+ flag = BOX3D_contained_internal(leaf, box);
+ break;
- case SPGSameStrategyNumber:
- flag = BOX3D_same_internal(leaf, box);
- break;
+ case SPGSameStrategyNumber:
+ flag = BOX3D_same_internal(leaf, box);
+ break;
- case SPGLeftStrategyNumber:
- flag = BOX3D_left_internal(leaf, box);
- break;
+ case SPGLeftStrategyNumber:
+ flag = BOX3D_left_internal(leaf, box);
+ break;
- case SPGOverLeftStrategyNumber:
- flag = BOX3D_overleft_internal(leaf, box);
- break;
+ case SPGOverLeftStrategyNumber:
+ flag = BOX3D_overleft_internal(leaf, box);
+ break;
- case SPGRightStrategyNumber:
- flag = BOX3D_right_internal(leaf, box);
- break;
+ case SPGRightStrategyNumber:
+ flag = BOX3D_right_internal(leaf, box);
+ break;
- case SPGOverRightStrategyNumber:
- flag = BOX3D_overright_internal(leaf, box);
- break;
+ case SPGOverRightStrategyNumber:
+ flag = BOX3D_overright_internal(leaf, box);
+ break;
- case SPGAboveStrategyNumber:
- flag = BOX3D_above_internal(leaf, box);
- break;
+ case SPGAboveStrategyNumber:
+ flag = BOX3D_above_internal(leaf, box);
+ break;
- case SPGOverAboveStrategyNumber:
- flag = BOX3D_overabove_internal(leaf, box);
- break;
+ case SPGOverAboveStrategyNumber:
+ flag = BOX3D_overabove_internal(leaf, box);
+ break;
- case SPGBelowStrategyNumber:
- flag = BOX3D_below_internal(leaf, box);
- break;
+ case SPGBelowStrategyNumber:
+ flag = BOX3D_below_internal(leaf, box);
+ break;
- case SPGOverBelowStrategyNumber:
- flag = BOX3D_overbelow_internal(leaf, box);
- break;
+ case SPGOverBelowStrategyNumber:
+ flag = BOX3D_overbelow_internal(leaf, box);
+ break;
- case SPGBackStrategyNumber:
- flag = BOX3D_back_internal(leaf, box);
- break;
+ case SPGBackStrategyNumber:
+ flag = BOX3D_back_internal(leaf, box);
+ break;
- case SPGOverBackStrategyNumber:
- flag = BOX3D_overback_internal(leaf, box);
- break;
+ case SPGOverBackStrategyNumber:
+ flag = BOX3D_overback_internal(leaf, box);
+ break;
- case SPGFrontStrategyNumber:
- flag = BOX3D_front_internal(leaf, box);
- break;
+ case SPGFrontStrategyNumber:
+ flag = BOX3D_front_internal(leaf, box);
+ break;
- case SPGOverFrontStrategyNumber:
- flag = BOX3D_overfront_internal(leaf, box);
- break;
+ case SPGOverFrontStrategyNumber:
+ flag = BOX3D_overfront_internal(leaf, box);
+ break;
- default:
- elog(ERROR, "unrecognized strategy: %d", strategy);
+ default:
+ elog(ERROR, "unrecognized strategy: %d", strategy);
}
/* If any check is failed, we have found our answer. */
PG_FUNCTION_INFO_V1(gserialized_spgist_compress_3d);
-PGDLLEXPORT Datum
-gserialized_spgist_compress_3d(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum gserialized_spgist_compress_3d(PG_FUNCTION_ARGS)
{
- BOX3D *result = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
+ BOX3D *result = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, PG_GETARG_DATUM(0)));
/* Is the bounding box is null */
- if ( result == LW_FAILURE )
+ if (result == LW_FAILURE)
{
PG_RETURN_NULL();
}
#define SPGSubEqualStrategyNumber 25 /* for inet <<= */
#define SPGSuperStrategyNumber 26 /* for inet << */
#define SPGSuperEqualStrategyNumber 27 /* for inet >>= */
-#define SPGOverFrontStrategyNumber 28 /* for &</ */
-#define SPGFrontStrategyNumber 29 /* for <</ */
-#define SPGBackStrategyNumber 30 /* for />> */
-#define SPGOverBackStrategyNumber 31 /* for /&> */
-
-/*****************************************************************************
- * BOX3D operators
- *****************************************************************************/
-
-
-bool BOX3D_contains_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_contained_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overlaps_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_same_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_left_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overleft_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_right_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overright_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_below_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overbelow_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_above_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overabove_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_front_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overfront_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_back_internal(BOX3D *box1, BOX3D *box2);
-bool BOX3D_overback_internal(BOX3D *box1, BOX3D *box2);
-double BOX3D_distance_internal(BOX3D *box1, BOX3D *box2);
+#define SPGOverFrontStrategyNumber 28 /* for &</ */
+#define SPGFrontStrategyNumber 29 /* for <</ */
+#define SPGBackStrategyNumber 30 /* for />> */
+#define SPGOverBackStrategyNumber 31 /* for /&> */
*
**********************************************************************
*
- * ^copyright^
+ * Copyright 2009 Mark Cave-Ayland <mark.cave-ayland@siriusit.co.uk>
+ * Copyright 2009-2017 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright 2018 Darafei Praliaskouski <me@komzpa.net>
*
**********************************************************************/
-
#include "postgres.h"
#include "fmgr.h"
#include "utils/elog.h"
#include "utils/geo_decls.h"
-/** needed for sp-gist support PostgreSQL 11+ **/
-#if POSTGIS_PGSQL_VERSION > 100
-#include "gserialized_spgist_3d.h"
-#endif
-
#include "../postgis_config.h"
#include "lwgeom_pg.h"
#include "liblwgeom.h"
+#include "lwgeom_box3d.h"
#include <math.h>
#include <float.h>
#include <errno.h>
#define SHOW_DIGS_DOUBLE 15
-#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 +1)
-
-/* forward defs */
-Datum BOX3D_in(PG_FUNCTION_ARGS);
-Datum BOX3D_out(PG_FUNCTION_ARGS);
-Datum LWGEOM_to_BOX3D(PG_FUNCTION_ARGS);
-Datum BOX3D_to_LWGEOM(PG_FUNCTION_ARGS);
-Datum BOX3D_expand(PG_FUNCTION_ARGS);
-Datum BOX3D_to_BOX2D(PG_FUNCTION_ARGS);
-Datum BOX3D_to_BOX(PG_FUNCTION_ARGS);
-Datum BOX3D_xmin(PG_FUNCTION_ARGS);
-Datum BOX3D_ymin(PG_FUNCTION_ARGS);
-Datum BOX3D_zmin(PG_FUNCTION_ARGS);
-Datum BOX3D_xmax(PG_FUNCTION_ARGS);
-Datum BOX3D_ymax(PG_FUNCTION_ARGS);
-Datum BOX3D_zmax(PG_FUNCTION_ARGS);
-Datum BOX3D_combine(PG_FUNCTION_ARGS);
-Datum BOX3D_combine_BOX3D(PG_FUNCTION_ARGS);
-
-/** needed for sp-gist support PostgreSQL 11+ **/
-#if POSTGIS_PGSQL_VERSION > 100
-Datum BOX3D_contains(PG_FUNCTION_ARGS);
-Datum BOX3D_contained(PG_FUNCTION_ARGS);
-Datum BOX3D_overlaps(PG_FUNCTION_ARGS);
-Datum BOX3D_same(PG_FUNCTION_ARGS);
-Datum BOX3D_left(PG_FUNCTION_ARGS);
-Datum BOX3D_overleft(PG_FUNCTION_ARGS);
-Datum BOX3D_right(PG_FUNCTION_ARGS) ;
-Datum BOX3D_overright(PG_FUNCTION_ARGS);
-Datum BOX3D_below(PG_FUNCTION_ARGS);
-Datum BOX3D_overbelow(PG_FUNCTION_ARGS);
-Datum BOX3D_above(PG_FUNCTION_ARGS);
-Datum BOX3D_overabove(PG_FUNCTION_ARGS);
-Datum BOX3D_front(PG_FUNCTION_ARGS);
-Datum BOX3D_overfront(PG_FUNCTION_ARGS);
-Datum BOX3D_back(PG_FUNCTION_ARGS);
-Datum BOX3D_overback(PG_FUNCTION_ARGS);
-Datum BOX3D_distance(PG_FUNCTION_ARGS);
-#endif
+#define MAX_DIGS_DOUBLE (SHOW_DIGS_DOUBLE + 6 + 1 + 3 + 1)
/**
* BOX3D_in - takes a string rep of BOX3D and returns internal rep
* "BOX3D(x1 y1 z1,x2 y2 z2)"
* or "BOX3D(x1 y1,x2 y2)" z1 and z2 = 0.0
*
- *
*/
PG_FUNCTION_INFO_V1(BOX3D_in);
{
char *str = PG_GETARG_CSTRING(0);
int nitems;
- BOX3D *box = (BOX3D *) palloc(sizeof(BOX3D));
+ BOX3D *box = (BOX3D *)palloc(sizeof(BOX3D));
box->zmin = 0;
box->zmax = 0;
-
- /*printf( "box3d_in gets '%s'\n",str); */
-
- if (strstr(str,"BOX3D(") != str )
+ if (strstr(str, "BOX3D(") != str)
{
pfree(box);
- elog(ERROR,"BOX3D parser - doesn't start with BOX3D(");
+ elog(ERROR, "BOX3D parser - doesn't start with BOX3D(");
PG_RETURN_NULL();
}
- nitems = sscanf(str,"BOX3D(%le %le %le ,%le %le %le)",
- &box->xmin, &box->ymin, &box->zmin,
- &box->xmax, &box->ymax, &box->zmax);
- if (nitems != 6 )
+ nitems = sscanf(str,
+ "BOX3D(%le %le %le ,%le %le %le)",
+ &box->xmin,
+ &box->ymin,
+ &box->zmin,
+ &box->xmax,
+ &box->ymax,
+ &box->zmax);
+ if (nitems != 6)
{
- nitems = sscanf(str,"BOX3D(%le %le ,%le %le)",
- &box->xmin, &box->ymin, &box->xmax, &box->ymax);
+ nitems = sscanf(str, "BOX3D(%le %le ,%le %le)", &box->xmin, &box->ymin, &box->xmax, &box->ymax);
if (nitems != 4)
{
pfree(box);
- elog(ERROR,"BOX3D parser - couldn't parse. It should look like: BOX3D(xmin ymin zmin,xmax ymax zmax) or BOX3D(xmin ymin,xmax ymax)");
+ elog(
+ ERROR,
+ "BOX3D parser - couldn't parse. It should look like: BOX3D(xmin ymin zmin,xmax ymax zmax) or BOX3D(xmin ymin,xmax ymax)");
PG_RETURN_NULL();
}
}
PG_RETURN_POINTER(box);
}
-
/**
* Takes an internal rep of a BOX3D and returns a string rep.
*
PG_FUNCTION_INFO_V1(BOX3D_out);
Datum BOX3D_out(PG_FUNCTION_ARGS)
{
- BOX3D *bbox = (BOX3D *) PG_GETARG_POINTER(0);
+ BOX3D *bbox = (BOX3D *)PG_GETARG_POINTER(0);
int size;
char *result;
if (bbox == NULL)
{
result = palloc(5);
- strcat(result,"NULL");
+ strcat(result, "NULL");
PG_RETURN_CSTRING(result);
}
+ /* double digits + "BOX3D"+ "()" + commas + null */
+ size = MAX_DIGS_DOUBLE * 6 + 5 + 2 + 4 + 5 + 1;
- /*double digits+ "BOX3D"+ "()" + commas +null */
- size = MAX_DIGS_DOUBLE*6+5+2+4+5+1;
-
- result = (char *) palloc(size);
+ result = (char *)palloc(size);
- sprintf(result, "BOX3D(%.15g %.15g %.15g,%.15g %.15g %.15g)",
- bbox->xmin, bbox->ymin, bbox->zmin,
- bbox->xmax,bbox->ymax,bbox->zmax);
+ sprintf(result,
+ "BOX3D(%.15g %.15g %.15g,%.15g %.15g %.15g)",
+ bbox->xmin,
+ bbox->ymin,
+ bbox->zmin,
+ bbox->xmax,
+ bbox->ymax,
+ bbox->zmax);
PG_RETURN_CSTRING(result);
}
-
PG_FUNCTION_INFO_V1(BOX3D_to_BOX2D);
Datum BOX3D_to_BOX2D(PG_FUNCTION_ARGS)
{
static void
box3d_to_box_p(BOX3D *box, BOX *out)
{
- if ( ! box ) return;
+ if (!box)
+ return;
out->low.x = box->xmin;
out->low.y = box->ymin;
PG_RETURN_POINTER(box);
}
-
PG_FUNCTION_INFO_V1(BOX3D_to_LWGEOM);
Datum BOX3D_to_LWGEOM(PG_FUNCTION_ARGS)
{
* Alter BOX3D cast so that a valid geometry is always
* returned depending upon the size of the BOX3D. The
* code makes the following assumptions:
- * - If the BOX3D is a single point then return a
- * POINT geometry
- * - If the BOX3D represents a line in any of X, Y
- * or Z dimension, return a LINESTRING geometry
- * - If the BOX3D represents a plane in the X, Y,
- * or Z dimension, return a POLYGON geometry
+ * - If the BOX3D is a single point then return a POINT geometry
+ * - If the BOX3D represents a line in any of X, Y or Z dimension,
+ * return a LINESTRING geometry
+ * - If the BOX3D represents a plane in the X, Y, or Z dimension,
+ * return a POLYGON geometry
* - Otherwise return a POLYHEDRALSURFACE geometry
*/
pa = ptarray_construct_empty(LW_TRUE, LW_FALSE, 5);
/* BOX3D is a point */
- if ( (box->xmin == box->xmax) && (box->ymin == box->ymax) &&
- (box->zmin == box->zmax) )
+ if ((box->xmin == box->xmax) && (box->ymin == box->ymax) && (box->zmin == box->zmax))
{
LWPOINT *lwpt = lwpoint_construct(SRID_UNKNOWN, NULL, pa);
lwpoint_free(lwpt);
}
/* BOX3D is a line */
- else if (((box->xmin == box->xmax ||
- box->ymin == box->ymax) &&
- box->zmin == box->zmax) ||
- ((box->xmin == box->xmax ||
- box->zmin == box->zmax) &&
- box->ymin == box->ymax) ||
- ((box->ymin == box->ymax ||
- box->zmin == box->zmax) &&
- box->xmin == box->xmax))
+ else if (((box->xmin == box->xmax || box->ymin == box->ymax) && box->zmin == box->zmax) ||
+ ((box->xmin == box->xmax || box->zmin == box->zmax) && box->ymin == box->ymax) ||
+ ((box->ymin == box->ymax || box->zmin == box->zmax) && box->xmin == box->xmax))
{
LWLINE *lwline = lwline_construct(SRID_UNKNOWN, NULL, pa);
LWPOLY *lwpoly;
/* Initialize the 4 vertices of the polygon */
- points[0] = (POINT4D) { box->xmin, box->ymin, box->zmin, 0.0 };
- points[1] = (POINT4D) { box->xmin, box->ymax, box->zmin, 0.0 };
- points[2] = (POINT4D) { box->xmin, box->ymax, box->zmax, 0.0 };
- points[3] = (POINT4D) { box->xmin, box->ymin, box->zmax, 0.0 };
+ points[0] = (POINT4D){box->xmin, box->ymin, box->zmin, 0.0};
+ points[1] = (POINT4D){box->xmin, box->ymax, box->zmin, 0.0};
+ points[2] = (POINT4D){box->xmin, box->ymax, box->zmax, 0.0};
+ points[3] = (POINT4D){box->xmin, box->ymin, box->zmax, 0.0};
- lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[1], &points[2], &points[3]);
+ lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[1], &points[2], &points[3]);
result = geometry_serialize(lwpoly_as_lwgeom(lwpoly));
lwpoly_free(lwpoly);
}
LWPOLY *lwpoly;
/* Initialize the 4 vertices of the polygon */
- points[0] = (POINT4D) { box->xmin, box->ymin, box->zmin, 0.0 };
- points[1] = (POINT4D) { box->xmax, box->ymin, box->zmin, 0.0 };
- points[2] = (POINT4D) { box->xmax, box->ymin, box->zmax, 0.0 };
- points[3] = (POINT4D) { box->xmin, box->ymin, box->zmax, 0.0 };
+ points[0] = (POINT4D){box->xmin, box->ymin, box->zmin, 0.0};
+ points[1] = (POINT4D){box->xmax, box->ymin, box->zmin, 0.0};
+ points[2] = (POINT4D){box->xmax, box->ymin, box->zmax, 0.0};
+ points[3] = (POINT4D){box->xmin, box->ymin, box->zmax, 0.0};
- lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[1], &points[2], &points[3]);
+ lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[1], &points[2], &points[3]);
result = geometry_serialize(lwpoly_as_lwgeom(lwpoly));
lwpoly_free(lwpoly);
}
LWPOLY *lwpoly;
/* Initialize the 4 vertices of the polygon */
- points[0] = (POINT4D) { box->xmin, box->ymin, box->zmin, 0.0 };
- points[1] = (POINT4D) { box->xmin, box->ymax, box->zmin, 0.0 };
- points[2] = (POINT4D) { box->xmax, box->ymax, box->zmin, 0.0 };
- points[3] = (POINT4D) { box->xmax, box->ymin, box->zmin, 0.0 };
+ points[0] = (POINT4D){box->xmin, box->ymin, box->zmin, 0.0};
+ points[1] = (POINT4D){box->xmin, box->ymax, box->zmin, 0.0};
+ points[2] = (POINT4D){box->xmax, box->ymax, box->zmin, 0.0};
+ points[3] = (POINT4D){box->xmax, box->ymin, box->zmin, 0.0};
- lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[1], &points[2], &points[3]);
+ lwpoly = lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[1], &points[2], &points[3]);
result = geometry_serialize(lwpoly_as_lwgeom(lwpoly));
lwpoly_free(lwpoly);
}
{
POINT4D points[8];
static const int ngeoms = 6;
- LWGEOM **geoms = (LWGEOM **) lwalloc(sizeof(LWGEOM *) * ngeoms);
+ LWGEOM **geoms = (LWGEOM **)lwalloc(sizeof(LWGEOM *) * ngeoms);
LWGEOM *geom = NULL;
/* Initialize the 8 vertices of the box */
- points[0] = (POINT4D) { box->xmin, box->ymin, box->zmin, 0.0 };
- points[1] = (POINT4D) { box->xmin, box->ymax, box->zmin, 0.0 };
- points[2] = (POINT4D) { box->xmax, box->ymax, box->zmin, 0.0 };
- points[3] = (POINT4D) { box->xmax, box->ymin, box->zmin, 0.0 };
- points[4] = (POINT4D) { box->xmin, box->ymin, box->zmax, 0.0 };
- points[5] = (POINT4D) { box->xmin, box->ymax, box->zmax, 0.0 };
- points[6] = (POINT4D) { box->xmax, box->ymax, box->zmax, 0.0 };
- points[7] = (POINT4D) { box->xmax, box->ymin, box->zmax, 0.0 };
+ points[0] = (POINT4D){box->xmin, box->ymin, box->zmin, 0.0};
+ points[1] = (POINT4D){box->xmin, box->ymax, box->zmin, 0.0};
+ points[2] = (POINT4D){box->xmax, box->ymax, box->zmin, 0.0};
+ points[3] = (POINT4D){box->xmax, box->ymin, box->zmin, 0.0};
+ points[4] = (POINT4D){box->xmin, box->ymin, box->zmax, 0.0};
+ points[5] = (POINT4D){box->xmin, box->ymax, box->zmax, 0.0};
+ points[6] = (POINT4D){box->xmax, box->ymax, box->zmax, 0.0};
+ points[7] = (POINT4D){box->xmax, box->ymin, box->zmax, 0.0};
/* add bottom polygon */
- geoms[0] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[1], &points[2], &points[3]));
+ geoms[0] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[1], &points[2], &points[3]));
/* add top polygon */
- geoms[1] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[4], &points[7], &points[6], &points[5]));
+ geoms[1] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[4], &points[7], &points[6], &points[5]));
/* add left polygon */
- geoms[2] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[4], &points[5], &points[1]));
+ geoms[2] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[4], &points[5], &points[1]));
/* add right polygon */
- geoms[3] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[3], &points[2], &points[6], &points[7]));
+ geoms[3] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[3], &points[2], &points[6], &points[7]));
/* add front polygon */
- geoms[4] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[0], &points[3], &points[7], &points[4]));
+ geoms[4] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[0], &points[3], &points[7], &points[4]));
/* add back polygon */
- geoms[5] = lwpoly_as_lwgeom(lwpoly_construct_rectangle(LW_TRUE, LW_FALSE,
- &points[1], &points[5], &points[6], &points[2]));
+ geoms[5] = lwpoly_as_lwgeom(
+ lwpoly_construct_rectangle(LW_TRUE, LW_FALSE, &points[1], &points[5], &points[6], &points[2]));
- geom = (LWGEOM *) lwcollection_construct(POLYHEDRALSURFACETYPE,
- SRID_UNKNOWN, NULL, ngeoms, geoms);
+ geom = (LWGEOM *)lwcollection_construct(POLYHEDRALSURFACETYPE, SRID_UNKNOWN, NULL, ngeoms, geoms);
FLAGS_SET_SOLID(geom->flags, 1);
result = geometry_serialize(geom);
- lwcollection_free((LWCOLLECTION *) geom);
+ lwcollection_free((LWCOLLECTION *)geom);
}
gserialized_set_srid(result, box->srid);
BOX3D *result = (BOX3D *)palloc(sizeof(BOX3D));
memcpy(result, box, sizeof(BOX3D));
- if (PG_NARGS() == 2) {
+ if (PG_NARGS() == 2)
+ {
/* Expand the box the same amount in all directions */
double d = PG_GETARG_FLOAT8(1);
expand_box3d(result, d);
/**
* convert a GSERIALIZED to BOX3D
*
- * NOTE: the bounding box is *always* recomputed as the cache
- * is a box2d, not a box3d...
+ * NOTE: the bounding box is always recomputed as the cache is a BOX2D, not a BOX3D.
*
*/
PG_FUNCTION_INFO_V1(LWGEOM_to_BOX3D);
BOX3D *result;
int rv = lwgeom_calculate_gbox(lwgeom, &gbox);
- if ( rv == LW_FAILURE )
+ if (rv == LW_FAILURE)
PG_RETURN_NULL();
result = box3d_from_gbox(&gbox);
}
/**
-* Used in the ST_Extent and ST_Extent3D aggregates, does not read the
-* serialized cached bounding box (since that is floating point)
-* but calculates the box in full from the underlying geometry.
-*/
+ * Used in the ST_Extent and ST_Extent3D aggregates, does not read the
+ * serialized cached bounding box (since that is floating point)
+ * but calculates the box in full from the underlying geometry.
+ */
PG_FUNCTION_INFO_V1(BOX3D_combine);
Datum BOX3D_combine(PG_FUNCTION_ARGS)
{
- BOX3D *box = (BOX3D*)PG_GETARG_POINTER(0);
- GSERIALIZED *geom = PG_ARGISNULL(1) ? NULL : (GSERIALIZED*)PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
+ BOX3D *box = (BOX3D *)PG_GETARG_POINTER(0);
+ GSERIALIZED *geom = PG_ARGISNULL(1) ? NULL : (GSERIALIZED *)PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
LWGEOM *lwgeom = NULL;
BOX3D *result = NULL;
GBOX gbox;
int rv;
/* Can't do anything with null inputs */
- if ((box == NULL) && (geom == NULL)) { PG_RETURN_NULL(); }
+ if (!box && !geom)
+ {
+ PG_RETURN_NULL();
+ }
/* Null geometry but non-null box, return the box */
- else if (geom == NULL)
+ else if (!geom)
{
result = palloc(sizeof(BOX3D));
memcpy(result, box, sizeof(BOX3D));
PG_RETURN_POINTER(result);
}
- /* Deserialize geometry and *calculate* the box */
- /* We can't use the cached box because it's float, we *must* calculate */
+ /*
+ * Deserialize geometry and *calculate* the box
+ * We can't use the cached box because it's float, we *must* calculate
+ */
lwgeom = lwgeom_from_gserialized(geom);
srid = lwgeom->srid;
rv = lwgeom_calculate_gbox(lwgeom, &gbox);
lwgeom_free(lwgeom);
/* If we couldn't calculate the box, return what we know */
- if ( rv == LW_FAILURE )
+ if (rv == LW_FAILURE)
{
PG_FREE_IF_COPY(geom, 1);
/* No geom box, no input box, so null return */
- if ( box == NULL )
+ if (!box)
PG_RETURN_NULL();
result = palloc(sizeof(BOX3D));
memcpy(result, box, sizeof(BOX3D));
}
/* Null box and non-null geometry, just return the geometry box */
- if ( box == NULL )
+ if (!box)
{
PG_FREE_IF_COPY(geom, 1);
result = box3d_from_gbox(&gbox);
PG_FUNCTION_INFO_V1(BOX3D_combine_BOX3D);
Datum BOX3D_combine_BOX3D(PG_FUNCTION_ARGS)
{
- BOX3D *box0 = (BOX3D*)(PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0));
- BOX3D *box1 = (BOX3D*)(PG_ARGISNULL(1) ? NULL : PG_GETARG_POINTER(1));
+ BOX3D *box0 = (BOX3D *)(PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0));
+ BOX3D *box1 = (BOX3D *)(PG_ARGISNULL(1) ? NULL : PG_GETARG_POINTER(1));
BOX3D *result;
if (box0 && !box1)
minpoint = lwgeom_from_gserialized(min);
maxpoint = lwgeom_from_gserialized(max);
- if ( minpoint->type != POINTTYPE ||
- maxpoint->type != POINTTYPE )
+ if (minpoint->type != POINTTYPE || maxpoint->type != POINTTYPE)
{
elog(ERROR, "BOX3D_construct: args must be points");
PG_RETURN_NULL();
*****************************************************************************/
/* contains? */
-
bool
BOX3D_contains_internal(BOX3D *box1, BOX3D *box2)
{
- return (box1->xmax >= box2->xmax &&
- box1->xmin <= box2->xmin &&
- box1->ymax >= box2->ymax &&
- box1->ymin <= box2->ymin &&
- box1->zmax >= box2->zmax &&
- box1->zmin <= box2->zmin);
+ return (box1->xmax >= box2->xmax && box1->xmin <= box2->xmin) &&
+ (box1->ymax >= box2->ymax && box1->ymin <= box2->ymin) &&
+ (box1->zmax >= box2->zmax && box1->zmin <= box2->zmin);
}
PG_FUNCTION_INFO_V1(BOX3D_contains);
-PGDLLEXPORT Datum
-BOX3D_contains(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_contains(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* contained by? */
-
bool
BOX3D_contained_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_contained);
-PGDLLEXPORT Datum
-BOX3D_contained(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_contained(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* overlaps? */
-
bool
BOX3D_overlaps_internal(BOX3D *box1, BOX3D *box2)
{
- return (box1->xmin <= box2->xmax &&
- box2->xmin <= box1->xmax &&
- box1->ymin <= box2->ymax &&
- box2->ymin <= box1->ymax &&
- box1->zmin <= box2->zmax &&
- box2->zmin <= box1->zmax);
+ return (box1->xmin <= box2->xmax && box2->xmin <= box1->xmax) &&
+ (box1->ymin <= box2->ymax && box2->ymin <= box1->ymax) &&
+ (box1->zmin <= box2->zmax && box2->zmin <= box1->zmax);
}
PG_FUNCTION_INFO_V1(BOX3D_overlaps);
-PGDLLEXPORT Datum
-BOX3D_overlaps(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overlaps(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* same? */
-
bool
BOX3D_same_internal(BOX3D *box1, BOX3D *box2)
{
- return (FPeq(box1->xmax, box2->xmax) &&
- FPeq(box1->xmin, box2->xmin) &&
- FPeq(box1->ymax, box2->ymax) &&
- FPeq(box1->ymin, box2->ymin) &&
- FPeq(box1->zmax, box2->zmax) &&
- FPeq(box1->zmin, box2->zmin));
+ return (FPeq(box1->xmax, box2->xmax) && FPeq(box1->xmin, box2->xmin)) &&
+ (FPeq(box1->ymax, box2->ymax) && FPeq(box1->ymin, box2->ymin)) &&
+ (FPeq(box1->zmax, box2->zmax) && FPeq(box1->zmin, box2->zmin));
}
PG_FUNCTION_INFO_V1(BOX3D_same);
-PGDLLEXPORT Datum
-BOX3D_same(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_same(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly left of? */
-
bool
BOX3D_left_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_left);
-PGDLLEXPORT Datum
-BOX3D_left(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_left(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend to right of? */
-
bool
BOX3D_overleft_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overleft);
-PGDLLEXPORT Datum
-BOX3D_overleft(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overleft(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly right of? */
-
bool
BOX3D_right_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_right);
-PGDLLEXPORT Datum
-BOX3D_right(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_right(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend to left of? */
-
bool
BOX3D_overright_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overright);
-PGDLLEXPORT Datum
-BOX3D_overright(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overright(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly below of? */
-
bool
BOX3D_below_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_below);
-PGDLLEXPORT Datum
-BOX3D_below(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_below(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend above of? */
-
bool
BOX3D_overbelow_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overbelow);
-PGDLLEXPORT Datum
-BOX3D_overbelow(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overbelow(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly above of? */
-
bool
BOX3D_above_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_above);
-PGDLLEXPORT Datum
-BOX3D_above(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_above(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend below of? */
-
bool
BOX3D_overabove_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overabove);
-PGDLLEXPORT Datum
-BOX3D_overabove(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overabove(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly in before of? */
-
bool
BOX3D_front_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_front);
-PGDLLEXPORT Datum
-BOX3D_front(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_front(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend to the after of? */
-
bool
BOX3D_overfront_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overfront);
-PGDLLEXPORT Datum
-BOX3D_overfront(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overfront(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* strictly after of? */
-
bool
BOX3D_back_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_back);
-PGDLLEXPORT Datum
-BOX3D_back(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_back(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* does not extend to the before of? */
-
bool
BOX3D_overback_internal(BOX3D *box1, BOX3D *box2)
{
PG_FUNCTION_INFO_V1(BOX3D_overback);
-PGDLLEXPORT Datum
-BOX3D_overback(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_overback(PG_FUNCTION_ARGS)
{
BOX3D *box1 = PG_GETARG_BOX3D_P(0);
BOX3D *box2 = PG_GETARG_BOX3D_P(1);
}
/* Minimum distance between 2 bounding boxes */
-
double
BOX3D_distance_internal(BOX3D *box1, BOX3D *box2)
{
- double sqrDist = 0;
- double d;
-
- if (BOX3D_overlaps_internal(box1, box2))
- return 0.0;
-
- /* X axis */
- if (box1->xmax < box2->xmin)
- {
- d = box1->xmax - box2->xmin;
- sqrDist += d * d;
- }
- else if (box1->xmin > box2->xmax)
- {
- d = box1->xmin - box2->xmax;
- sqrDist += d * d;
- }
- /* Y axis */
- if (box1->ymax < box2->ymin)
- {
- d = box1->ymax - box2->ymin;
- sqrDist += d * d;
- }
- else if (box1->ymin > box2->ymax)
- {
- d = box1->ymin - box2->ymax;
- sqrDist += d * d;
- }
- /* Z axis */
- if (box1->zmax < box2->zmin)
- {
- d = box1->zmax - box2->zmin;
- sqrDist += d * d;
- }
- else if (box1->zmin > box2->zmax)
- {
- d = box1->zmin - box2->zmax;
- sqrDist += d * d;
- }
-
- return sqrt(sqrDist);
+ double sqrDist = 0;
+ double d;
+
+ if (BOX3D_overlaps_internal(box1, box2))
+ return 0.0;
+
+ /* X axis */
+ if (box1->xmax < box2->xmin)
+ {
+ d = box1->xmax - box2->xmin;
+ sqrDist += d * d;
+ }
+ else if (box1->xmin > box2->xmax)
+ {
+ d = box1->xmin - box2->xmax;
+ sqrDist += d * d;
+ }
+ /* Y axis */
+ if (box1->ymax < box2->ymin)
+ {
+ d = box1->ymax - box2->ymin;
+ sqrDist += d * d;
+ }
+ else if (box1->ymin > box2->ymax)
+ {
+ d = box1->ymin - box2->ymax;
+ sqrDist += d * d;
+ }
+ /* Z axis */
+ if (box1->zmax < box2->zmin)
+ {
+ d = box1->zmax - box2->zmin;
+ sqrDist += d * d;
+ }
+ else if (box1->zmin > box2->zmax)
+ {
+ d = box1->zmin - box2->zmax;
+ sqrDist += d * d;
+ }
+
+ return sqrt(sqrDist);
}
PG_FUNCTION_INFO_V1(BOX3D_distance);
-PGDLLEXPORT Datum
-BOX3D_distance(PG_FUNCTION_ARGS)
+PGDLLEXPORT Datum BOX3D_distance(PG_FUNCTION_ARGS)
{
- BOX3D *box1 = PG_GETARG_BOX3D_P(0);
- BOX3D *box2 = PG_GETARG_BOX3D_P(1);
- PG_RETURN_FLOAT8(BOX3D_distance_internal(box1, box2));
+ BOX3D *box1 = PG_GETARG_BOX3D_P(0);
+ BOX3D *box2 = PG_GETARG_BOX3D_P(1);
+ PG_RETURN_FLOAT8(BOX3D_distance_internal(box1, box2));
}
#endif
--- /dev/null
+/**********************************************************************
+ *
+ * PostGIS - Spatial Types for PostgreSQL
+ * http://postgis.net
+ *
+ * PostGIS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * PostGIS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with PostGIS. If not, see <http://www.gnu.org/licenses/>.
+ *
+ **********************************************************************
+ *
+ * Copyright 2009 Mark Cave-Ayland <mark.cave-ayland@siriusit.co.uk>
+ * Copyright 2009-2017 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright 2018 Darafei Praliaskouski <me@komzpa.net>
+ *
+ **********************************************************************/
+
+/* forward defs */
+Datum BOX3D_in(PG_FUNCTION_ARGS);
+Datum BOX3D_out(PG_FUNCTION_ARGS);
+Datum LWGEOM_to_BOX3D(PG_FUNCTION_ARGS);
+Datum BOX3D_to_LWGEOM(PG_FUNCTION_ARGS);
+Datum BOX3D_expand(PG_FUNCTION_ARGS);
+Datum BOX3D_to_BOX2D(PG_FUNCTION_ARGS);
+Datum BOX3D_to_BOX(PG_FUNCTION_ARGS);
+Datum BOX3D_xmin(PG_FUNCTION_ARGS);
+Datum BOX3D_ymin(PG_FUNCTION_ARGS);
+Datum BOX3D_zmin(PG_FUNCTION_ARGS);
+Datum BOX3D_xmax(PG_FUNCTION_ARGS);
+Datum BOX3D_ymax(PG_FUNCTION_ARGS);
+Datum BOX3D_zmax(PG_FUNCTION_ARGS);
+Datum BOX3D_combine(PG_FUNCTION_ARGS);
+Datum BOX3D_combine_BOX3D(PG_FUNCTION_ARGS);
+
+/*****************************************************************************
+ * BOX3D operators
+ *****************************************************************************/
+
+bool BOX3D_contains_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_contained_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overlaps_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_same_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_left_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overleft_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_right_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overright_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_below_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overbelow_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_above_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overabove_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_front_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overfront_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_back_internal(BOX3D *box1, BOX3D *box2);
+bool BOX3D_overback_internal(BOX3D *box1, BOX3D *box2);
+double BOX3D_distance_internal(BOX3D *box1, BOX3D *box2);
+
+/** needed for sp-gist support PostgreSQL 11+ **/
+#if POSTGIS_PGSQL_VERSION > 100
+Datum BOX3D_contains(PG_FUNCTION_ARGS);
+Datum BOX3D_contained(PG_FUNCTION_ARGS);
+Datum BOX3D_overlaps(PG_FUNCTION_ARGS);
+Datum BOX3D_same(PG_FUNCTION_ARGS);
+Datum BOX3D_left(PG_FUNCTION_ARGS);
+Datum BOX3D_overleft(PG_FUNCTION_ARGS);
+Datum BOX3D_right(PG_FUNCTION_ARGS);
+Datum BOX3D_overright(PG_FUNCTION_ARGS);
+Datum BOX3D_below(PG_FUNCTION_ARGS);
+Datum BOX3D_overbelow(PG_FUNCTION_ARGS);
+Datum BOX3D_above(PG_FUNCTION_ARGS);
+Datum BOX3D_overabove(PG_FUNCTION_ARGS);
+Datum BOX3D_front(PG_FUNCTION_ARGS);
+Datum BOX3D_overfront(PG_FUNCTION_ARGS);
+Datum BOX3D_back(PG_FUNCTION_ARGS);
+Datum BOX3D_overback(PG_FUNCTION_ARGS);
+Datum BOX3D_distance(PG_FUNCTION_ARGS);
+#endif
projects / postgis / commitdiff