lwgeom_rectree.c

Go to the documentation of this file.

/**********************************************************************
 *
 * 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 (C) 2018 Paul Ramsey
 *
 **********************************************************************/
 
 
#include "postgres.h"
#include "funcapi.h"
#include "fmgr.h"
#include "liblwgeom.h"
#include "liblwgeom_internal.h"  /* For FP comparators. */
#include "lwgeom_pg.h"
#include "lwtree.h"
#include "lwgeom_cache.h"
 
 
/* Prototypes */
Datum ST_DistanceRectTree(PG_FUNCTION_ARGS);
Datum ST_DistanceRectTreeCached(PG_FUNCTION_ARGS);
 
 
/**********************************************************************
* RectTree Caching support
**********************************************************************/
 
/*
* Specific tree types include all the generic slots and
* their own slots for their trees. We put the implementation
* for the RectTreeGeomCache here because we can't shove
* the PgSQL specific bits of the code (fcinfo) back into
* liblwgeom/lwtree.c, where most of the rect_tree logic lives.
*/
typedef struct {
        GeomCache           gcache;
        RECT_NODE           *index;
} RectTreeGeomCache;
 
 
static int
RectTreeBuilder(const LWGEOM *lwgeom, GeomCache *cache)
{
        RectTreeGeomCache *rect_cache = (RectTreeGeomCache*)cache;
        RECT_NODE *tree = rect_tree_from_lwgeom(lwgeom);
 
        if ( rect_cache->index )
        {
                rect_tree_free(rect_cache->index);
                rect_cache->index = 0;
        }
        if ( ! tree )
                return LW_FAILURE;
 
        rect_cache->index = tree;
        return LW_SUCCESS;
}
 
static int
RectTreeFreer(GeomCache *cache)
{
        RectTreeGeomCache *rect_cache = (RectTreeGeomCache*)cache;
        if ( rect_cache->index )
        {
                rect_tree_free(rect_cache->index);
                rect_cache->index = 0;
                rect_cache->gcache.argnum = 0;
        }
        return LW_SUCCESS;
}
 
static GeomCache *
RectTreeAllocator(void)
{
        RectTreeGeomCache *cache = palloc(sizeof(RectTreeGeomCache));
        memset(cache, 0, sizeof(RectTreeGeomCache));
        return (GeomCache*)cache;
}
 
static GeomCacheMethods RectTreeCacheMethods =
{
        RECT_CACHE_ENTRY,
        RectTreeBuilder,
        RectTreeFreer,
        RectTreeAllocator
};
 
static RectTreeGeomCache *
GetRectTreeGeomCache(FunctionCallInfo fcinfo, SHARED_GSERIALIZED *g1, SHARED_GSERIALIZED *g2)
{
        return (RectTreeGeomCache*)GetGeomCache(fcinfo, &RectTreeCacheMethods, g1, g2);
}
 
 
/**********************************************************************
* ST_DistanceRectTree
**********************************************************************/
 
PG_FUNCTION_INFO_V1(ST_DistanceRectTree);
Datum ST_DistanceRectTree(PG_FUNCTION_ARGS)
{
        GSERIALIZED *g1 = PG_GETARG_GSERIALIZED_P(0);
        GSERIALIZED *g2 = PG_GETARG_GSERIALIZED_P(1);
        LWGEOM *lwg1, *lwg2;
        RECT_NODE *n1, *n2;
 
        /* Return NULL on empty arguments. */
        if (gserialized_is_empty(g1) || gserialized_is_empty(g2))
        {
                PG_FREE_IF_COPY(g1, 0);
                PG_FREE_IF_COPY(g2, 1);
                PG_RETURN_NULL();
        }
 
        lwg1 = lwgeom_from_gserialized(g1);
        lwg2 = lwgeom_from_gserialized(g2);
 
        /* Two points? Get outa here... */
        if (lwg1->type == POINTTYPE && lwg2->type == POINTTYPE)
                PG_RETURN_FLOAT8(lwgeom_mindistance2d(lwg1, lwg2));
 
 
        n1 = rect_tree_from_lwgeom(lwg1);
        n2 = rect_tree_from_lwgeom(lwg2);
        PG_RETURN_FLOAT8(rect_tree_distance_tree(n1, n2, 0.0));
}
 
PG_FUNCTION_INFO_V1(ST_DistanceRectTreeCached);
Datum ST_DistanceRectTreeCached(PG_FUNCTION_ARGS)
{
        RectTreeGeomCache *tree_cache = NULL;
        SHARED_GSERIALIZED *shared_geom1 = ToastCacheGetGeometry(fcinfo, 0);
        SHARED_GSERIALIZED *shared_geom2 = ToastCacheGetGeometry(fcinfo, 1);
        const GSERIALIZED *g1 = shared_gserialized_get(shared_geom1);
        const GSERIALIZED *g2 = shared_gserialized_get(shared_geom2);
 
        /* Return NULL on empty arguments. */
        if (gserialized_is_empty(g1) || gserialized_is_empty(g2))
        {
                PG_RETURN_NULL();
        }
 
        /* Two points? Get outa here... */
        if (gserialized_get_type(g1) == POINTTYPE && gserialized_get_type(g2) == POINTTYPE)
        {
                LWGEOM *lwg1 = lwgeom_from_gserialized(g1);
                LWGEOM *lwg2 = lwgeom_from_gserialized(g2);
                PG_RETURN_FLOAT8(lwgeom_mindistance2d(lwg1, lwg2));
        }
 
        /* Fetch/build our cache, if appropriate, etc... */
        tree_cache = GetRectTreeGeomCache(fcinfo, shared_geom1, shared_geom2);
 
        if (tree_cache && tree_cache->gcache.argnum)
        {
                RECT_NODE *n;
                RECT_NODE *n_cached = tree_cache->index;
                if (tree_cache->gcache.argnum == 1)
                {
                        LWGEOM *lwg2 = lwgeom_from_gserialized(g2);
                        n = rect_tree_from_lwgeom(lwg2);
                }
                else if (tree_cache->gcache.argnum == 2)
                {
                        LWGEOM *lwg1 = lwgeom_from_gserialized(g1);
                        n = rect_tree_from_lwgeom(lwg1);
                }
                else
                {
                        elog(ERROR, "reached unreachable block in %s", __func__);
                }
                PG_RETURN_FLOAT8(rect_tree_distance_tree(n, n_cached, 0.0));
        }
        else
        {
                LWGEOM *lwg1 = lwgeom_from_gserialized(g1);
                LWGEOM *lwg2 = lwgeom_from_gserialized(g2);
                PG_RETURN_FLOAT8(lwgeom_mindistance2d(lwg1, lwg2));
        }
 
        PG_RETURN_NULL();
}