circ_node_internal_new()

static CIRC_NODE* circ_node_internal_new ( CIRC_NODE **  c, uint32_t  num_nodes  )

static

Create a new internal node, calculating the new measure range for the node, and storing pointers to the child nodes.

Definition at line 230 of file lwgeodetic_tree.c.

{
        CIRC_NODE *node = NULL;
        GEOGRAPHIC_POINT new_center, c1;
        double new_radius;
        double offset1, dist, D, r1, ri;
        uint32_t i, new_geom_type;
 
        LWDEBUGF(3, "called with %d nodes --", num_nodes);
 
        /* Can't do anything w/ empty input */
        if ( num_nodes < 1 )
                return node;
 
        /* Initialize calculation with values of the first circle */
        new_center = c[0]->center;
        new_radius = c[0]->radius;
        new_geom_type = c[0]->geom_type;
 
        /* Merge each remaining circle into the new circle */
        for ( i = 1; i < num_nodes; i++ )
        {
                c1 = new_center;
                r1 = new_radius;
 
                dist = sphere_distance(&c1, &(c[i]->center));
                ri = c[i]->radius;
 
                /* Promote geometry types up the tree, getting more and more collected */
                /* Go until we find a value */
                if ( ! new_geom_type )
                {
                        new_geom_type = c[i]->geom_type;
                }
                /* Promote singleton to a multi-type */
                else if ( ! lwtype_is_collection(new_geom_type) )
                {
                        /* Anonymous collection if types differ */
                        if ( new_geom_type != c[i]->geom_type )
                        {
                                new_geom_type = COLLECTIONTYPE;
                        }
                        else
                        {
                                new_geom_type = lwtype_get_collectiontype(new_geom_type);
                        }
                }
                /* If we can't add next feature to this collection cleanly, promote again to anonymous collection */
                else if ( new_geom_type != lwtype_get_collectiontype(c[i]->geom_type) )
                {
                        new_geom_type = COLLECTIONTYPE;
                }
 
 
                LWDEBUGF(3, "distance between new (%g %g) and %i (%g %g) is %g", c1.lon, c1.lat, i, c[i]->center.lon, c[i]->center.lat, dist);
 
                if ( FP_EQUALS(dist, 0) )
                {
                        LWDEBUG(3, "  distance between centers is zero");
                        new_radius = r1 + 2*dist;
                        new_center = c1;
                }
                else if ( dist < fabs(r1 - ri) )
                {
                        /* new contains next */
                        if ( r1 > ri )
                        {
                                LWDEBUG(3, "  c1 contains ci");
                                new_center = c1;
                                new_radius = r1;
                        }
                        /* next contains new */
                        else
                        {
                                LWDEBUG(3, "  ci contains c1");
                                new_center = c[i]->center;
                                new_radius = ri;
                        }
                }
                else
                {
                        LWDEBUG(3, "  calculating new center");
                        /* New circle diameter */
                        D = dist + r1 + ri;
                        LWDEBUGF(3,"    D is %g", D);
 
                        /* New radius */
                        new_radius = D / 2.0;
 
                        /* Distance from cn1 center to the new center */
                        offset1 = ri + (D - (2.0*r1 + 2.0*ri)) / 2.0;
                        LWDEBUGF(3,"    offset1 is %g", offset1);
 
                        /* Sometimes the sphere_direction function fails... this causes the center calculation */
                        /* to fail too. In that case, we're going to fall back to a cartesian calculation, which */
                        /* is less exact, so we also have to pad the radius by (hack alert) an arbitrary amount */
                        /* which is hopefully always big enough to contain the input edges */
                        if ( circ_center_spherical(&c1, &(c[i]->center), dist, offset1, &new_center) == LW_FAILURE )
                        {
                                circ_center_cartesian(&c1, &(c[i]->center), dist, offset1, &new_center);
                                new_radius *= 1.1;
                        }
                }
                LWDEBUGF(3, " new center is (%g %g) new radius is %g", new_center.lon, new_center.lat, new_radius);
        }
 
        node = lwalloc(sizeof(CIRC_NODE));
        node->p1 = NULL;
        node->p2 = NULL;
        node->center = new_center;
        node->radius = new_radius;
        node->num_nodes = num_nodes;
        node->nodes = c;
        node->edge_num = -1;
        node->geom_type = new_geom_type;
        node->pt_outside.x = 0.0;
        node->pt_outside.y = 0.0;
        return node;
}

References circ_node::center, circ_center_cartesian(), circ_center_spherical(), COLLECTIONTYPE, circ_node::edge_num, FP_EQUALS, circ_node::geom_type, GEOGRAPHIC_POINT::lat, GEOGRAPHIC_POINT::lon, LW_FAILURE, lwalloc(), LWDEBUG, LWDEBUGF, lwtype_get_collectiontype(), lwtype_is_collection(), circ_node::nodes, circ_node::num_nodes, circ_node::p1, circ_node::p2, circ_node::pt_outside, circ_node::radius, sphere_distance(), POINT2D::x, and POINT2D::y.

Referenced by circ_nodes_merge().

Here is the call graph for this function:

Here is the caller graph for this function: