PostGIS  2.1.10dev-r@@SVN_REVISION@@
static double circ_tree_distance_tree_internal ( const CIRC_NODE n1,
const CIRC_NODE n2,
double  threshold,
double *  min_dist,
double *  max_dist,
GEOGRAPHIC_POINT closest1,
GEOGRAPHIC_POINT closest2 
)
static

Definition at line 574 of file lwgeodetic_tree.c.

References circ_node_is_leaf(), circ_node_max_distance(), circ_node_min_distance(), circ_tree_contains_point(), circ_tree_get_point(), edge_distance_to_edge(), edge_distance_to_point(), edge_intersection(), edge_intersects(), circ_node::edge_num, GEOGRAPHIC_EDGE::end, FP_MIN, geog2cart(), geographic_point_init(), circ_node::geom_type, LWDEBUG, LWDEBUGF, lwtype_is_collection(), MAXFLOAT, circ_node::nodes, circ_node::num_nodes, circ_node::p1, circ_node::p2, POLYGONTYPE, circ_node::pt_outside, sphere_distance(), GEOGRAPHIC_EDGE::start, POINT2D::x, and POINT2D::y.

Referenced by circ_tree_distance_tree().

575 {
576  double max;
577  double d, d_min;
578  int i;
579 
580  LWDEBUGF(4, "entered, min_dist=%.8g max_dist=%.8g, type1=%d, type2=%d", *min_dist, *max_dist, n1->geom_type, n2->geom_type);
581 // circ_tree_print(n1, 0);
582 // circ_tree_print(n2, 0);
583 
584  /* Short circuit if we've already hit the minimum */
585  if( *min_dist <= threshold )
586  return *min_dist;
587 
588  /* If your minimum is greater than anyone's maximum, you can't hold the winner */
589  if( circ_node_min_distance(n1, n2) > *max_dist )
590  {
591  LWDEBUGF(4, "pruning pair %p, %p", n1, n2);
592  return MAXFLOAT;
593  }
594 
595  /* If your maximum is a new low, we'll use that as our new global tolerance */
596  max = circ_node_max_distance(n1, n2);
597  LWDEBUGF(5, "max %.8g", max);
598  if( max < *max_dist )
599  *max_dist = max;
600 
601  /* Polygon on one side, primitive type on the other. Check for point-in-polygon */
602  /* short circuit. */
603  if ( n1->geom_type == POLYGONTYPE && n2->geom_type && ! lwtype_is_collection(n2->geom_type) )
604  {
605  POINT2D pt;
606  circ_tree_get_point(n2, &pt);
607  LWDEBUGF(4, "n1 is polygon, testing if contains (%.5g,%.5g)", pt.x, pt.y);
608  if ( circ_tree_contains_point(n1, &pt, &(n1->pt_outside), NULL) )
609  {
610  LWDEBUG(4, "it does");
611  *min_dist = 0.0;
612  geographic_point_init(pt.x, pt.y, closest1);
613  geographic_point_init(pt.x, pt.y, closest2);
614  return *min_dist;
615  }
616  }
617  /* Polygon on one side, primitive type on the other. Check for point-in-polygon */
618  /* short circuit. */
619  if ( n2->geom_type == POLYGONTYPE && n1->geom_type && ! lwtype_is_collection(n1->geom_type) )
620  {
621  POINT2D pt;
622  circ_tree_get_point(n1, &pt);
623  LWDEBUGF(4, "n2 is polygon, testing if contains (%.5g,%.5g)", pt.x, pt.y);
624  if ( circ_tree_contains_point(n2, &pt, &(n2->pt_outside), NULL) )
625  {
626  LWDEBUG(4, "it does");
627  geographic_point_init(pt.x, pt.y, closest1);
628  geographic_point_init(pt.x, pt.y, closest2);
629  *min_dist = 0.0;
630  return *min_dist;
631  }
632  }
633 
634  /* Both leaf nodes, do a real distance calculation */
635  if( circ_node_is_leaf(n1) && circ_node_is_leaf(n2) )
636  {
637  double d;
638  GEOGRAPHIC_POINT close1, close2;
639  LWDEBUGF(4, "testing leaf pair [%d], [%d]", n1->edge_num, n2->edge_num);
640  /* One of the nodes is a point */
641  if ( n1->p1 == n1->p2 || n2->p1 == n2->p2 )
642  {
643  GEOGRAPHIC_EDGE e;
644  GEOGRAPHIC_POINT gp1, gp2;
645 
646  /* Both nodes are points! */
647  if ( n1->p1 == n1->p2 && n2->p1 == n2->p2 )
648  {
649  geographic_point_init(n1->p1->x, n1->p1->y, &gp1);
650  geographic_point_init(n2->p1->x, n2->p1->y, &gp2);
651  close1 = gp1; close2 = gp2;
652  d = sphere_distance(&gp1, &gp2);
653  }
654  /* Node 1 is a point */
655  else if ( n1->p1 == n1->p2 )
656  {
657  geographic_point_init(n1->p1->x, n1->p1->y, &gp1);
658  geographic_point_init(n2->p1->x, n2->p1->y, &(e.start));
659  geographic_point_init(n2->p2->x, n2->p2->y, &(e.end));
660  close1 = gp1;
661  d = edge_distance_to_point(&e, &gp1, &close2);
662  }
663  /* Node 2 is a point */
664  else
665  {
666  geographic_point_init(n2->p1->x, n2->p1->y, &gp1);
667  geographic_point_init(n1->p1->x, n1->p1->y, &(e.start));
668  geographic_point_init(n1->p2->x, n1->p2->y, &(e.end));
669  close1 = gp1;
670  d = edge_distance_to_point(&e, &gp1, &close2);
671  }
672  LWDEBUGF(4, " got distance %g", d);
673  }
674  /* Both nodes are edges */
675  else
676  {
677  GEOGRAPHIC_EDGE e1, e2;
679  POINT3D A1, A2, B1, B2;
680  geographic_point_init(n1->p1->x, n1->p1->y, &(e1.start));
681  geographic_point_init(n1->p2->x, n1->p2->y, &(e1.end));
682  geographic_point_init(n2->p1->x, n2->p1->y, &(e2.start));
683  geographic_point_init(n2->p2->x, n2->p2->y, &(e2.end));
684  geog2cart(&(e1.start), &A1);
685  geog2cart(&(e1.end), &A2);
686  geog2cart(&(e2.start), &B1);
687  geog2cart(&(e2.end), &B2);
688  if ( edge_intersects(&A1, &A2, &B1, &B2) )
689  {
690  d = 0.0;
691  edge_intersection(&e1, &e2, &g);
692  close1 = close2 = g;
693  }
694  else
695  {
696  d = edge_distance_to_edge(&e1, &e2, &close1, &close2);
697  }
698  LWDEBUGF(4, "edge_distance_to_edge returned %g", d);
699  }
700  if ( d < *min_dist )
701  {
702  *min_dist = d;
703  *closest1 = close1;
704  *closest2 = close2;
705  }
706  return d;
707  }
708  else
709  {
710  d_min = MAXFLOAT;
711  /* Drive the recursion into the COLLECTION types first so we end up with */
712  /* pairings of primitive geometries that can be forced into the point-in-polygon */
713  /* tests above. */
714  if ( n1->geom_type && lwtype_is_collection(n1->geom_type) )
715  {
716  for ( i = 0; i < n1->num_nodes; i++ )
717  {
718  d = circ_tree_distance_tree_internal(n1->nodes[i], n2, threshold, min_dist, max_dist, closest1, closest2);
719  d_min = FP_MIN(d_min, d);
720  }
721  }
722  else if ( n2->geom_type && lwtype_is_collection(n2->geom_type) )
723  {
724  for ( i = 0; i < n2->num_nodes; i++ )
725  {
726  d = circ_tree_distance_tree_internal(n1, n2->nodes[i], threshold, min_dist, max_dist, closest1, closest2);
727  d_min = FP_MIN(d_min, d);
728  }
729  }
730  else if ( ! circ_node_is_leaf(n1) )
731  {
732  for ( i = 0; i < n1->num_nodes; i++ )
733  {
734  d = circ_tree_distance_tree_internal(n1->nodes[i], n2, threshold, min_dist, max_dist, closest1, closest2);
735  d_min = FP_MIN(d_min, d);
736  }
737  }
738  else if ( ! circ_node_is_leaf(n2) )
739  {
740  for ( i = 0; i < n2->num_nodes; i++ )
741  {
742  d = circ_tree_distance_tree_internal(n1, n2->nodes[i], threshold, min_dist, max_dist, closest1, closest2);
743  d_min = FP_MIN(d_min, d);
744  }
745  }
746  else
747  {
748  /* Never get here */
749  }
750 
751  return d_min;
752  }
753 }
double sphere_distance(const GEOGRAPHIC_POINT *s, const GEOGRAPHIC_POINT *e)
Given two points on a unit sphere, calculate their distance apart in radians.
Definition: lwgeodetic.c:897
double edge_distance_to_edge(const GEOGRAPHIC_EDGE *e1, const GEOGRAPHIC_EDGE *e2, GEOGRAPHIC_POINT *closest1, GEOGRAPHIC_POINT *closest2)
Calculate the distance between two edges.
Definition: lwgeodetic.c:1216
Two-point great circle segment from a to b.
Definition: lwgeodetic.h:42
int circ_tree_get_point(const CIRC_NODE *node, POINT2D *pt)
Returns a POINT2D that is a vertex of the input shape.
POINT2D * p2
#define POLYGONTYPE
Definition: liblwgeom.h:62
POINT2D * p1
#define LWDEBUG(level, msg)
Definition: lwgeom_log.h:50
static double circ_tree_distance_tree_internal(const CIRC_NODE *n1, const CIRC_NODE *n2, double threshold, double *min_dist, double *max_dist, GEOGRAPHIC_POINT *closest1, GEOGRAPHIC_POINT *closest2)
#define FP_MIN(A, B)
Point in spherical coordinates on the world.
Definition: lwgeodetic.h:33
double x
Definition: liblwgeom.h:284
static int circ_node_is_leaf(const CIRC_NODE *node)
Internal nodes have their point references set to NULL.
static double circ_node_max_distance(const CIRC_NODE *n1, const CIRC_NODE *n2)
GEOGRAPHIC_POINT start
Definition: lwgeodetic.h:44
double edge_distance_to_point(const GEOGRAPHIC_EDGE *e, const GEOGRAPHIC_POINT *gp, GEOGRAPHIC_POINT *closest)
Definition: lwgeodetic.c:1165
int circ_tree_contains_point(const CIRC_NODE *node, const POINT2D *pt, const POINT2D *pt_outside, int *on_boundary)
Walk the tree and count intersections between the stab line and the edges.
int lwtype_is_collection(uint8_t type)
Determine whether a type number is a collection or not.
Definition: lwgeom.c:955
GEOGRAPHIC_POINT end
Definition: lwgeodetic.h:45
double y
Definition: liblwgeom.h:284
void geog2cart(const GEOGRAPHIC_POINT *g, POINT3D *p)
Convert spherical coordinates to cartesion coordinates on unit sphere.
Definition: lwgeodetic.c:355
int edge_intersects(const POINT3D *A1, const POINT3D *A2, const POINT3D *B1, const POINT3D *B2)
Returns non-zero if edges A and B interact.
Definition: lwgeodetic.c:3096
static double circ_node_min_distance(const CIRC_NODE *n1, const CIRC_NODE *n2)
void geographic_point_init(double lon, double lat, GEOGRAPHIC_POINT *g)
Initialize a geographic point.
Definition: lwgeodetic.c:157
POINT2D pt_outside
#define MAXFLOAT
Largest float value.
#define LWDEBUGF(level, msg,...)
Definition: lwgeom_log.h:55
int edge_intersection(const GEOGRAPHIC_EDGE *e1, const GEOGRAPHIC_EDGE *e2, GEOGRAPHIC_POINT *g)
Returns true if an intersection can be calculated, and places it in *g.
Definition: lwgeodetic.c:1074
struct circ_node ** nodes

Here is the call graph for this function:

Here is the caller graph for this function: