path_inter, path_distance, path_length, dist_ppath now do the right

things with closed paths --- ie, include the closing line segment in
their calculations.  Per bug report from Curtis Barrett 9-Oct-01.

diff --git a/src/backend/utils/adt/geo_ops.c b/src/backend/utils/adt/geo_ops.c
index aac191b377856163e190cdf1326f1c8c71e36227..4590500ecad39ac9518947b832d8a4b09b0755e2 100644 (file)
--- a/src/backend/utils/adt/geo_ops.c
+++ b/src/backend/utils/adt/geo_ops.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.58 2001/03/22 03:59:50 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.59 2001/10/13 17:40:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -948,7 +948,7 @@ line_construct_pts(LINE *line, Point *pt1, Point *pt2)
    }
    else if (FPeq(pt1->y, pt2->y))
    {                           /* horizontal */
-       /* use "x = C" */
+       /* use "y = C" */
        line->A = 0;
        line->B = -1;
        line->C = pt1->y;
@@ -1376,6 +1376,9 @@ path_inter(PG_FUNCTION_ARGS)
    LSEG        seg1,
                seg2;
 
+   if (p1->npts <= 0 || p2->npts <= 0)
+       PG_RETURN_BOOL(false);
+
    b1.high.x = b1.low.x = p1->p[0].x;
    b1.high.y = b1.low.y = p1->p[0].y;
    for (i = 1; i < p1->npts; i++)
@@ -1398,12 +1401,34 @@ path_inter(PG_FUNCTION_ARGS)
        PG_RETURN_BOOL(false);
 
    /* pairwise check lseg intersections */
-   for (i = 0; i < p1->npts - 1; i++)
+   for (i = 0; i < p1->npts; i++)
    {
-       for (j = 0; j < p2->npts - 1; j++)
+       int iprev;
+
+       if (i > 0)
+           iprev = i-1;
+       else
        {
-           statlseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
-           statlseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
+           if (!p1->closed)
+               continue;
+           iprev = p1->npts-1; /* include the closure segment */
+       }
+
+       for (j = 0; j < p2->npts; j++)
+       {
+           int jprev;
+
+           if (j > 0)
+               jprev = j-1;
+           else
+           {
+               if (!p2->closed)
+                   continue;
+               jprev = p2->npts-1; /* include the closure segment */
+           }
+
+           statlseg_construct(&seg1, &p1->p[iprev], &p1->p[i]);
+           statlseg_construct(&seg2, &p2->p[jprev], &p2->p[j]);
            if (lseg_intersect_internal(&seg1, &seg2))
                PG_RETURN_BOOL(true);
        }
@@ -1422,20 +1447,42 @@ path_distance(PG_FUNCTION_ARGS)
 {
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
-   bool        have_min = false;
    float8      min = 0.0;      /* initialize to keep compiler quiet */
+   bool        have_min = false;
    float8      tmp;
    int         i,
                j;
    LSEG        seg1,
                seg2;
 
-   for (i = 0; i < p1->npts - 1; i++)
+   for (i = 0; i < p1->npts; i++)
    {
-       for (j = 0; j < p2->npts - 1; j++)
+       int iprev;
+
+       if (i > 0)
+           iprev = i-1;
+       else
        {
-           statlseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
-           statlseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
+           if (!p1->closed)
+               continue;
+           iprev = p1->npts-1; /* include the closure segment */
+       }
+
+       for (j = 0; j < p2->npts; j++)
+       {
+           int jprev;
+
+           if (j > 0)
+               jprev = j-1;
+           else
+           {
+               if (!p2->closed)
+                   continue;
+               jprev = p2->npts-1; /* include the closure segment */
+           }
+
+           statlseg_construct(&seg1, &p1->p[iprev], &p1->p[i]);
+           statlseg_construct(&seg2, &p2->p[jprev], &p2->p[j]);
 
            tmp = DatumGetFloat8(DirectFunctionCall2(lseg_distance,
                                                     LsegPGetDatum(&seg1),
@@ -1463,12 +1510,24 @@ Datum
 path_length(PG_FUNCTION_ARGS)
 {
    PATH       *path = PG_GETARG_PATH_P(0);
-   float8      result;
+   float8      result = 0.0;
    int         i;
 
-   result = 0.0;
-   for (i = 0; i < (path->npts - 1); i++)
-       result += point_dt(&path->p[i], &path->p[i + 1]);
+   for (i = 0; i < path->npts; i++)
+   {
+       int iprev;
+
+       if (i > 0)
+           iprev = i-1;
+       else
+       {
+           if (!path->closed)
+               continue;
+           iprev = path->npts-1;   /* include the closure segment */
+       }
+
+       result += point_dt(&path->p[iprev], &path->p[i]);
+   }
 
    PG_RETURN_FLOAT8(result);
 }
@@ -2133,17 +2192,18 @@ dist_ppath(PG_FUNCTION_ARGS)
    Point      *pt = PG_GETARG_POINT_P(0);
    PATH       *path = PG_GETARG_PATH_P(1);
    float8      result = 0.0;   /* keep compiler quiet */
+   bool        have_min = false;
    float8      tmp;
    int         i;
    LSEG        lseg;
 
    switch (path->npts)
    {
-           /* no points in path? then result is undefined... */
        case 0:
+           /* no points in path? then result is undefined... */
            PG_RETURN_NULL();
-           /* one point in path? then get distance between two points... */
        case 1:
+           /* one point in path? then get distance between two points... */
            result = point_dt(pt, &path->p[0]);
            break;
        default:
@@ -2154,12 +2214,26 @@ dist_ppath(PG_FUNCTION_ARGS)
             * the distance from a point to a path is the smallest
             * distance from the point to any of its constituent segments.
             */
-           for (i = 0; i < path->npts - 1; i++)
+           for (i = 0; i < path->npts; i++)
            {
-               statlseg_construct(&lseg, &path->p[i], &path->p[i + 1]);
+               int iprev;
+
+               if (i > 0)
+                   iprev = i-1;
+               else
+               {
+                   if (!path->closed)
+                       continue;
+                   iprev = path->npts-1;   /* include the closure segment */
+               }
+
+               statlseg_construct(&lseg, &path->p[iprev], &path->p[i]);
                tmp = dist_ps_internal(pt, &lseg);
-               if (i == 0 || tmp < result)
+               if (!have_min || tmp < result)
+               {
                    result = tmp;
+                   have_min = true;
+               }
            }
            break;
    }
@@ -2824,8 +2898,6 @@ on_pb(PG_FUNCTION_ARGS)
  *             but not cross.
  *             (we can do p-in-p in lg(n), but it takes preprocessing)
  */
-#define NEXT(A) (((A)+1) % path->npts) /* cyclic "i+1" */
-
 Datum
 on_ppath(PG_FUNCTION_ARGS)
 {