geography_distance_cache_tolerance()

static int geography_distance_cache_tolerance ( FunctionCallInfo  fcinfo, SHARED_GSERIALIZED *  shared_g1, SHARED_GSERIALIZED *  shared_g2, const SPHEROID *  s, double  tolerance, double *  distance  )

static

Definition at line 157 of file geography_measurement_trees.c.

{
        const GSERIALIZED *g1 = shared_gserialized_get(shared_g1);
        const GSERIALIZED *g2 = shared_gserialized_get(shared_g2);
        CircTreeGeomCache* tree_cache = NULL;
 
        int type1 = gserialized_get_type(g1);
        int type2 = gserialized_get_type(g2);
 
        Assert(distance);
 
        /* Two points? Get outa here... */
        if ( type1 == POINTTYPE && type2 == POINTTYPE )
                return LW_FAILURE;
 
        /* Fetch/build our cache, if appropriate, etc... */
        tree_cache = GetCircTreeGeomCache(fcinfo, shared_g1, shared_g2);
 
        /* OK, we have an index at the ready! Use it for the one tree argument and */
        /* fill in the other tree argument */
        if ( tree_cache && tree_cache->gcache.argnum && tree_cache->index )
        {
                CIRC_NODE* circtree_cached = tree_cache->index;
                CIRC_NODE* circtree = NULL;
                const GSERIALIZED* g_cached;
                const GSERIALIZED* g;
                LWGEOM* lwgeom = NULL;
                int geomtype_cached;
                int geomtype;
                POINT4D p4d;
 
                /* We need to dynamically build a tree for the uncached side of the function call */
                if ( tree_cache->gcache.argnum == 1 )
                {
                        g_cached = g1;
                        g = g2;
                        geomtype_cached = type1;
                        geomtype = type2;
                }
                else if ( tree_cache->gcache.argnum == 2 )
                {
                        g_cached = g2;
                        g = g1;
                        geomtype_cached = type2;
                        geomtype = type1;
                }
                else
                {
                        lwpgerror("geography_distance_cache this cannot happen!");
                        return LW_FAILURE;
                }
 
                lwgeom = lwgeom_from_gserialized(g);
                if ( geomtype_cached == POLYGONTYPE || geomtype_cached == MULTIPOLYGONTYPE )
                {
                        lwgeom_startpoint(lwgeom, &p4d);
                        if ( CircTreePIP(circtree_cached, g_cached, &p4d) )
                        {
                                *distance = 0.0;
                                lwgeom_free(lwgeom);
                                return LW_SUCCESS;
                        }
                }
 
                circtree = lwgeom_calculate_circ_tree(lwgeom);
                if ( geomtype == POLYGONTYPE || geomtype == MULTIPOLYGONTYPE )
                {
                        POINT2D p2d;
                        circ_tree_get_point(circtree_cached, &p2d);
                        p4d.x = p2d.x;
                        p4d.y = p2d.y;
                        if ( CircTreePIP(circtree, g, &p4d) )
                        {
                                *distance = 0.0;
                                circ_tree_free(circtree);
                                lwgeom_free(lwgeom);
                                return LW_SUCCESS;
                        }
                }
 
                *distance = circ_tree_distance_tree(circtree_cached, circtree, s, tolerance);
                circ_tree_free(circtree);
                lwgeom_free(lwgeom);
                return LW_SUCCESS;
        }
        else
        {
                return LW_FAILURE;
        }
}

References circ_tree_distance_tree(), circ_tree_free(), circ_tree_get_point(), CircTreePIP(), distance(), CircTreeGeomCache::gcache, GetCircTreeGeomCache(), gserialized_get_type(), CircTreeGeomCache::index, LW_FAILURE, LW_SUCCESS, lwgeom_calculate_circ_tree(), lwgeom_free(), lwgeom_from_gserialized(), lwgeom_startpoint(), MULTIPOLYGONTYPE, POINTTYPE, POLYGONTYPE, s, POINT2D::x, POINT4D::x, POINT2D::y, and POINT4D::y.

Referenced by geography_distance_cache(), and geography_dwithin_cache().

Here is the call graph for this function:

Here is the caller graph for this function: