You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by kw...@apache.org on 2019/02/26 13:44:38 UTC

[lucene-solr] branch branch_7_7 updated: LUCENE-8696: Refactor, in preparation for creating a new SegmentEndpoint implementation to fix the problem.

This is an automated email from the ASF dual-hosted git repository.

kwright pushed a commit to branch branch_7_7
in repository https://gitbox.apache.org/repos/asf/lucene-solr.git


The following commit(s) were added to refs/heads/branch_7_7 by this push:
     new a6c6304  LUCENE-8696: Refactor, in preparation for creating a new SegmentEndpoint implementation to fix the problem.
a6c6304 is described below

commit a6c6304ba099ecf6c4bf6c4b669c5c3177f71ae1
Author: Karl Wright <Da...@gmail.com>
AuthorDate: Tue Feb 26 08:43:48 2019 -0500

    LUCENE-8696: Refactor, in preparation for creating a new SegmentEndpoint implementation to fix the problem.
---
 .../lucene/spatial3d/geom/GeoStandardPath.java     | 501 ++++++++++++++-------
 .../apache/lucene/spatial3d/geom/GeoPathTest.java  |  17 +-
 2 files changed, 357 insertions(+), 161 deletions(-)

diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoStandardPath.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoStandardPath.java
index 395b76e..6f15b2c 100755
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoStandardPath.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoStandardPath.java
@@ -148,7 +148,7 @@ class GeoStandardPath extends GeoBasePath {
       // Construct normal plane
       final Plane normalPlane = Plane.constructNormalizedZPlane(upperPoint, lowerPoint, point);
 
-      final SegmentEndpoint onlyEndpoint = new SegmentEndpoint(point, normalPlane, upperPoint, lowerPoint);
+      final CircleSegmentEndpoint onlyEndpoint = new CircleSegmentEndpoint(point, normalPlane, upperPoint, lowerPoint);
       endPoints.add(onlyEndpoint);
       this.edgePoints = new GeoPoint[]{onlyEndpoint.circlePlane.getSampleIntersectionPoint(planetModel, normalPlane)};
       return;
@@ -160,7 +160,7 @@ class GeoStandardPath extends GeoBasePath {
       
       if (i == 0) {
         // Starting endpoint
-        final SegmentEndpoint startEndpoint = new SegmentEndpoint(currentSegment.start, 
+        final SegmentEndpoint startEndpoint = new CutoffSingleCircleSegmentEndpoint(currentSegment.start, 
           currentSegment.startCutoffPlane, currentSegment.ULHC, currentSegment.LLHC);
         endPoints.add(startEndpoint);
         this.edgePoints = new GeoPoint[]{currentSegment.ULHC};
@@ -178,12 +178,12 @@ class GeoStandardPath extends GeoBasePath {
       if (candidate1 == null && candidate2 == null && candidate3 == null && candidate4 == null) {
         // The planes are identical.  We wouldn't need a circle at all except for the possibility of
         // backing up, which is hard to detect here.
-        final SegmentEndpoint midEndpoint = new SegmentEndpoint(currentSegment.start, 
+        final SegmentEndpoint midEndpoint = new CutoffSingleCircleSegmentEndpoint(currentSegment.start, 
           prevSegment.endCutoffPlane, currentSegment.startCutoffPlane, currentSegment.ULHC, currentSegment.LLHC);
         //don't need a circle at all.  Special constructor...
         endPoints.add(midEndpoint);
       } else {
-        endPoints.add(new SegmentEndpoint(currentSegment.start,
+        endPoints.add(new CutoffDualCircleSegmentEndpoint(currentSegment.start,
           prevSegment.endCutoffPlane, currentSegment.startCutoffPlane,
           prevSegment.URHC, prevSegment.LRHC,
           currentSegment.ULHC, currentSegment.LLHC,
@@ -192,7 +192,7 @@ class GeoStandardPath extends GeoBasePath {
     }
     // Do final endpoint
     final PathSegment lastSegment = segments.get(segments.size()-1);
-    endPoints.add(new SegmentEndpoint(lastSegment.end,
+    endPoints.add(new CutoffSingleCircleSegmentEndpoint(lastSegment.end,
       lastSegment.endCutoffPlane, lastSegment.URHC, lastSegment.LRHC));
 
   }
@@ -458,7 +458,8 @@ class GeoStandardPath extends GeoBasePath {
   }
 
   /**
-   * This is precalculated data for segment endpoint.
+   * Internal interface describing segment endpoint implementations.
+   * There are several different such implementations, each corresponding to a different geometric conformation.
    * Note well: This is not necessarily a circle.  There are four cases:
    * (1) The path consists of a single endpoint.  In this case, we build a simple circle with the proper cutoff offset.
    * (2) This is the end of a path.  The circle plane must be constructed to go through two supplied points and be perpendicular to a connecting plane.
@@ -467,43 +468,258 @@ class GeoStandardPath extends GeoBasePath {
    *    we generate no circle at all.  If there is one intersection only, then we generate a plane that includes that intersection, as well as the remaining
    *    cutoff plane/edge plane points.
    */
-  private static class SegmentEndpoint {
+  private interface SegmentEndpoint {
+    
+    /** Check if point is within this endpoint.
+     *@param point is the point.
+     *@return true of within.
+     */
+    boolean isWithin(final Vector point);
+
+    /** Check if point is within this endpoint.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return true of within.
+     */
+    boolean isWithin(final double x, final double y, final double z);
+    
+    /** Compute delta path distance.
+     *@param distanceStyle is the distance style.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return the distance metric, in aggregation form.
+     */
+    double pathDeltaDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z);
+
+    /** Compute interior path distance.
+     *@param distanceStyle is the distance style.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return the distance metric, in aggregation form.
+     */
+    double pathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z);
+
+    /** Compute nearest path distance.
+     *@param distanceStyle is the distance style.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return the distance metric (always value zero), in aggregation form, or POSITIVE_INFINITY
+     * if the point is not within the bounds of the endpoint.
+     */
+    double nearestPathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z);
+
+    /** Compute path center distance.
+     *@param distanceStyle is the distance style.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return the distance metric, or POSITIVE_INFINITY
+     * if the point is not within the bounds of the endpoint.
+     */
+    double pathCenterDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z);
+
+    /** Compute external distance.
+     *@param distanceStyle is the distance style.
+     *@param x is the point x.
+     *@param y is the point y.
+     *@param z is the point z.
+     *@return the distance metric.
+     */
+    double outsideDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z);
+
+    /** Determine if this endpoint intersects a specified plane.
+     *@param planetModel is the planet model.
+     *@param p is the plane.
+     *@param notablePoints are the points associated with the plane.
+     *@param bounds are any bounds which the intersection must lie within.
+     *@return true if there is a matching intersection.
+     */
+    boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds);
+
+    /** Determine if this endpoint intersects a GeoShape.
+     *@param geoShape is the GeoShape.
+     *@return true if there is shape intersect this endpoint.
+     */
+    boolean intersects(final GeoShape geoShape);
+
+    /** Get the bounds for a segment endpoint.
+     *@param planetModel is the planet model.
+     *@param bounds are the bounds to be modified.
+     */
+    void getBounds(final PlanetModel planetModel, Bounds bounds);
+  }
+
+  /**
+   * Base implementation of SegmentEndpoint
+   */
+  private static class BaseSegmentEndpoint implements SegmentEndpoint {
     /** The center point of the endpoint */
-    public final GeoPoint point;
-    /** A plane describing the circle */
-    public final SidedPlane circlePlane;
-    /** Pertinent cutoff planes from adjoining segments */
-    public final Membership[] cutoffPlanes;
-    /** Notable points for this segment endpoint */
-    public final GeoPoint[] notablePoints;
-    /** No notable points from the circle itself */
-    public final static GeoPoint[] circlePoints = new GeoPoint[0];
+    protected final GeoPoint point;
     /** Null membership */
-    public final static Membership[] NO_MEMBERSHIP = new Membership[0];
+    protected final static Membership[] NO_MEMBERSHIP = new Membership[0];
     
-    /** Base case.  Does nothing at all.
-     */
-    public SegmentEndpoint(final GeoPoint point) {
+    public BaseSegmentEndpoint(final GeoPoint point) {
       this.point = point;
-      this.circlePlane = null;
-      this.cutoffPlanes = null;
-      this.notablePoints = null;
+    }
+
+    @Override
+    public boolean isWithin(final Vector point) {
+      return false;
+    }
+
+    @Override
+    public boolean isWithin(final double x, final double y, final double z) {
+      return false;
+    }
+
+    @Override
+    public double pathDeltaDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      if (!isWithin(x,y,z))
+        return Double.POSITIVE_INFINITY;
+      final double theDistance = distanceStyle.toAggregationForm(distanceStyle.computeDistance(this.point, x, y, z));
+      return distanceStyle.aggregateDistances(theDistance, theDistance);
+    }
+
+    @Override
+    public double pathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      if (!isWithin(x,y,z))
+        return Double.POSITIVE_INFINITY;
+      return distanceStyle.toAggregationForm(distanceStyle.computeDistance(this.point, x, y, z));
+    }
+
+    @Override
+    public double nearestPathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      return distanceStyle.toAggregationForm(0.0);
+    }
+
+    @Override
+    public double pathCenterDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      return distanceStyle.computeDistance(this.point, x, y, z);
+    }
+
+    @Override
+    public double outsideDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      return distanceStyle.computeDistance(this.point, x, y, z);
+    }
+
+    @Override
+    public boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds) {
+      return false;
+    }
+
+    @Override
+    public boolean intersects(final GeoShape geoShape) {
+      return false;
+    }
+
+    @Override
+    public void getBounds(final PlanetModel planetModel, Bounds bounds) {
+      bounds.addPoint(point);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+      if (!(o instanceof BaseSegmentEndpoint))
+        return false;
+      final BaseSegmentEndpoint other = (BaseSegmentEndpoint) o;
+      return point.equals(other.point);
     }
     
+    @Override
+    public int hashCode() {
+      return point.hashCode();
+    }
+    
+    @Override
+    public String toString() {
+      return point.toString();
+    }
+    
+  }
+  
+  /**
+   * Simplest possible implementation of segment endpoint: a single point.
+   */
+  private static class DegenerateSegmentEndpoint extends BaseSegmentEndpoint {
+
+    public DegenerateSegmentEndpoint(final GeoPoint point) {
+      super(point);
+    }
+
+  }
+  
+  /**
+   * Endpoint that's a simple circle.
+   */
+  private static class CircleSegmentEndpoint extends BaseSegmentEndpoint {
+    /** A plane describing the circle */
+    protected final SidedPlane circlePlane;
+    /** No notable points from the circle itself */
+    protected final static GeoPoint[] circlePoints = new GeoPoint[0];
+
     /** Constructor for case (1).
      * Generate a simple circle cutoff plane.
      *@param point is the center point.
      *@param upperPoint is a point that must be on the circle plane.
      *@param lowerPoint is another point that must be on the circle plane.
      */
-    public SegmentEndpoint(final GeoPoint point, final Plane normalPlane, final GeoPoint upperPoint, final GeoPoint lowerPoint) {
-      this.point = point;
+    public CircleSegmentEndpoint(final GeoPoint point, final Plane normalPlane, final GeoPoint upperPoint, final GeoPoint lowerPoint) {
+      super(point);
       // Construct a sided plane that goes through the two points and whose normal is in the normalPlane.
       this.circlePlane = SidedPlane.constructNormalizedPerpendicularSidedPlane(point, normalPlane, upperPoint, lowerPoint);
-      this.cutoffPlanes = NO_MEMBERSHIP;
-      this.notablePoints = circlePoints;
+    }
+
+    /** Constructor for case (3).  Called by superclass only.
+     *@param point is the center point.
+     *@param circlePlane is the circle plane.
+     */
+    protected CircleSegmentEndpoint(final GeoPoint point, final SidedPlane circlePlane) {
+      super(point);
+      this.circlePlane = circlePlane;
     }
     
+    @Override
+    public boolean isWithin(final Vector point) {
+      return circlePlane.isWithin(point);
+    }
+
+    @Override
+    public boolean isWithin(final double x, final double y, final double z) {
+      return circlePlane.isWithin(x, y, z);
+    }
+
+    @Override
+    public boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds) {
+      return circlePlane.intersects(planetModel, p, notablePoints, circlePoints, bounds);
+    }
+
+    @Override
+    public boolean intersects(final GeoShape geoShape) {
+      return geoShape.intersects(circlePlane, circlePoints, NO_MEMBERSHIP);
+    }
+
+    @Override
+    public void getBounds(final PlanetModel planetModel, Bounds bounds) {
+      super.getBounds(planetModel, bounds);
+      bounds.addPlane(planetModel, circlePlane);
+    }
+    
+  }
+  
+  /**
+   * Endpoint that's a single circle with cutoff(s).
+   */
+  private static class CutoffSingleCircleSegmentEndpoint extends CircleSegmentEndpoint {
+    
+    /** Pertinent cutoff plane from adjoining segments */
+    protected final Membership[] cutoffPlanes;
+    /** Notable points for this segment endpoint */
+    private final GeoPoint[] notablePoints;
+
     /** Constructor for case (2).
      * Generate an endpoint, given a single cutoff plane plus upper and lower edge points.
      *@param point is the center point.
@@ -511,13 +727,11 @@ class GeoStandardPath extends GeoBasePath {
      *@param topEdgePoint is a point on the cutoffPlane that should be also on the circle plane.
      *@param bottomEdgePoint is another point on the cutoffPlane that should be also on the circle plane.
      */
-    public SegmentEndpoint(final GeoPoint point,
+    public CutoffSingleCircleSegmentEndpoint(final GeoPoint point,
       final SidedPlane cutoffPlane, final GeoPoint topEdgePoint, final GeoPoint bottomEdgePoint) {
-      this.point = point;
+      super(point, cutoffPlane, topEdgePoint, bottomEdgePoint);
       this.cutoffPlanes = new Membership[]{new SidedPlane(cutoffPlane)};
       this.notablePoints = new GeoPoint[]{topEdgePoint, bottomEdgePoint};
-      // To construct the plane, we now just need D, which is simply the negative of the evaluation of the circle normal vector at one of the points.
-      this.circlePlane = SidedPlane.constructNormalizedPerpendicularSidedPlane(point, cutoffPlane, topEdgePoint, bottomEdgePoint);
     }
 
     /** Constructor for case (2.5).
@@ -528,15 +742,85 @@ class GeoStandardPath extends GeoBasePath {
      *@param topEdgePoint is a point on the cutoffPlane that should be also on the circle plane.
      *@param bottomEdgePoint is another point on the cutoffPlane that should be also on the circle plane.
      */
-    public SegmentEndpoint(final GeoPoint point,
+    public CutoffSingleCircleSegmentEndpoint(final GeoPoint point,
       final SidedPlane cutoffPlane1, final SidedPlane cutoffPlane2, final GeoPoint topEdgePoint, final GeoPoint bottomEdgePoint) {
-      this.point = point;
+      super(point, cutoffPlane1, topEdgePoint, bottomEdgePoint);
       this.cutoffPlanes = new Membership[]{new SidedPlane(cutoffPlane1), new SidedPlane(cutoffPlane2)};
       this.notablePoints = new GeoPoint[]{topEdgePoint, bottomEdgePoint};
-      // To construct the plane, we now just need D, which is simply the negative of the evaluation of the circle normal vector at one of the points.
-      this.circlePlane = SidedPlane.constructNormalizedPerpendicularSidedPlane(point, cutoffPlane1, topEdgePoint, bottomEdgePoint);
     }
+
+    @Override
+    public boolean isWithin(final Vector point) {
+      if (!super.isWithin(point)) {
+        return false;
+      }
+      for (final Membership m : cutoffPlanes) {
+        if (!m.isWithin(point)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    @Override
+    public boolean isWithin(final double x, final double y, final double z) {
+      if (!super.isWithin(x, y, z)) {
+        return false;
+      }
+      for (final Membership m : cutoffPlanes) {
+        if (!m.isWithin(x,y,z)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    @Override
+    public double nearestPathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      for (final Membership m : cutoffPlanes) {
+        if (!m.isWithin(x,y,z)) {
+          return Double.POSITIVE_INFINITY;
+        }
+      }
+      return super.nearestPathDistance(distanceStyle, x, y, z);
+    }
+
+    @Override
+    public double pathCenterDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
+      for (final Membership m : cutoffPlanes) {
+        if (!m.isWithin(x,y,z)) {
+          return Double.POSITIVE_INFINITY;
+        }
+      }
+      return super.pathCenterDistance(distanceStyle, x, y, z);
+    }
+
+    @Override
+    public boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds) {
+      return circlePlane.intersects(planetModel, p, notablePoints, this.notablePoints, bounds, this.cutoffPlanes);
+    }
+
+    @Override
+    public boolean intersects(final GeoShape geoShape) {
+      return geoShape.intersects(circlePlane, this.notablePoints, this.cutoffPlanes);
+    }
+
+  }
+  
+  /**
+   * Endpoint that's a dual circle with cutoff(s).
+   */
+  private static class CutoffDualCircleSegmentEndpoint extends BaseSegmentEndpoint {
+    
+    // For now, keep the old implementation
+    // MHL
+    protected final SidedPlane circlePlane;
     
+    /** Pertinent cutoff plane from adjoining segments */
+    protected final Membership[] cutoffPlanes;
+    /** Notable points for this segment endpoint */
+    private final GeoPoint[] notablePoints;
+
     /** Constructor for case (3).
      * Generate an endpoint for an intersection, given four points.
      *@param point is the center.
@@ -551,7 +835,7 @@ class GeoStandardPath extends GeoBasePath {
      *@param candidate3 one of four candidate circle planes.
      *@param candidate4 one of four candidate circle planes.
      */
-    public SegmentEndpoint(final GeoPoint point,
+    public CutoffDualCircleSegmentEndpoint(final GeoPoint point,
       final SidedPlane prevCutoffPlane, final SidedPlane nextCutoffPlane,
       final GeoPoint notCand2Point, final GeoPoint notCand1Point,
       final GeoPoint notCand3Point, final GeoPoint notCand4Point,
@@ -565,8 +849,8 @@ class GeoStandardPath extends GeoBasePath {
       // The solution is to look for the side (top or bottom) that has an intersection within the shape.  We use the two points from
       // the opposite side to determine the plane, AND we pick the third to be either of the two points on the intersecting side
       // PROVIDED that the other point is within the final circle we come up with.
-      this.point = point;
-      
+      super(point);
+
       // We construct four separate planes, and evaluate which one includes all interior points with least overlap
       // (Constructed beforehand because we need them for degeneracy check)
 
@@ -591,7 +875,7 @@ class GeoStandardPath extends GeoBasePath {
         this.notablePoints = new GeoPoint[]{notCand3Point, notCand4Point, notCand1Point};
         this.cutoffPlanes = new Membership[]{new SidedPlane(nextCutoffPlane)};
       } else if (cand3IsOtherWithin) {
-        this.circlePlane = candidate3;
+        circlePlane = candidate3;
         this.notablePoints = new GeoPoint[]{notCand4Point, notCand1Point, notCand2Point};
         this.cutoffPlanes = new Membership[]{new SidedPlane(prevCutoffPlane)};
       } else if (cand4IsOtherWithin) {
@@ -604,15 +888,11 @@ class GeoStandardPath extends GeoBasePath {
       }
     }
 
-    /** Check if point is within this endpoint.
-     *@param point is the point.
-     *@return true of within.
-     */
+    @Override
     public boolean isWithin(final Vector point) {
-      if (circlePlane == null)
-        return false;
-      if (!circlePlane.isWithin(point))
+      if (!circlePlane.isWithin(point)) {
         return false;
+      }
       for (final Membership m : cutoffPlanes) {
         if (!m.isWithin(point)) {
           return false;
@@ -621,17 +901,11 @@ class GeoStandardPath extends GeoBasePath {
       return true;
     }
 
-    /** Check if point is within this endpoint.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return true of within.
-     */
+    @Override
     public boolean isWithin(final double x, final double y, final double z) {
-      if (circlePlane == null)
-        return false;
-      if (!circlePlane.isWithin(x, y, z))
+      if (!circlePlane.isWithin(x, y, z)) {
         return false;
+      }
       for (final Membership m : cutoffPlanes) {
         if (!m.isWithin(x,y,z)) {
           return false;
@@ -640,133 +914,44 @@ class GeoStandardPath extends GeoBasePath {
       return true;
     }
 
-    /** Compute delta path distance.
-     *@param distanceStyle is the distance style.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return the distance metric, in aggregation form.
-     */
-    public double pathDeltaDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
-      if (!isWithin(x,y,z))
-        return Double.POSITIVE_INFINITY;
-      final double theDistance = distanceStyle.toAggregationForm(distanceStyle.computeDistance(this.point, x, y, z));
-      return distanceStyle.aggregateDistances(theDistance, theDistance);
-    }
-
-    /** Compute interior path distance.
-     *@param distanceStyle is the distance style.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return the distance metric, in aggregation form.
-     */
-    public double pathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
-      if (!isWithin(x,y,z))
-        return Double.POSITIVE_INFINITY;
-      return distanceStyle.toAggregationForm(distanceStyle.computeDistance(this.point, x, y, z));
-    }
-
-    /** Compute nearest path distance.
-     *@param distanceStyle is the distance style.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return the distance metric (always value zero), in aggregation form, or POSITIVE_INFINITY
-     * if the point is not within the bounds of the endpoint.
-     */
+    @Override
     public double nearestPathDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
       for (final Membership m : cutoffPlanes) {
         if (!m.isWithin(x,y,z)) {
           return Double.POSITIVE_INFINITY;
         }
       }
-      return distanceStyle.toAggregationForm(0.0);
+      return super.nearestPathDistance(distanceStyle, x, y, z);
     }
 
-    /** Compute path center distance.
-     *@param distanceStyle is the distance style.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return the distance metric, or POSITIVE_INFINITY
-     * if the point is not within the bounds of the endpoint.
-     */
+    @Override
     public double pathCenterDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
       for (final Membership m : cutoffPlanes) {
         if (!m.isWithin(x,y,z)) {
           return Double.POSITIVE_INFINITY;
         }
       }
-      return distanceStyle.computeDistance(this.point, x, y, z);
+      return super.pathCenterDistance(distanceStyle, x, y, z);
     }
 
-    /** Compute external distance.
-     *@param distanceStyle is the distance style.
-     *@param x is the point x.
-     *@param y is the point y.
-     *@param z is the point z.
-     *@return the distance metric.
-     */
-    public double outsideDistance(final DistanceStyle distanceStyle, final double x, final double y, final double z) {
-      return distanceStyle.computeDistance(this.point, x, y, z);
-    }
-
-    /** Determine if this endpoint intersects a specified plane.
-     *@param planetModel is the planet model.
-     *@param p is the plane.
-     *@param notablePoints are the points associated with the plane.
-     *@param bounds are any bounds which the intersection must lie within.
-     *@return true if there is a matching intersection.
-     */
+    @Override
     public boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds) {
-      //System.err.println("  looking for intersection between plane "+p+" and circle "+circlePlane+" on proper side of "+cutoffPlanes+" within "+bounds);
-      if (circlePlane == null)
-        return false;
       return circlePlane.intersects(planetModel, p, notablePoints, this.notablePoints, bounds, this.cutoffPlanes);
     }
 
-    /** Determine if this endpoint intersects a GeoShape.
-     *@param geoShape is the GeoShape.
-     *@return true if there is shape intersect this endpoint.
-     */
+    @Override
     public boolean intersects(final GeoShape geoShape) {
-      //System.err.println("  looking for intersection between plane "+p+" and circle "+circlePlane+" on proper side of "+cutoffPlanes+" within "+bounds);
-      if (circlePlane == null)
-        return false;
       return geoShape.intersects(circlePlane, this.notablePoints, this.cutoffPlanes);
     }
 
-    /** Get the bounds for a segment endpoint.
-     *@param planetModel is the planet model.
-     *@param bounds are the bounds to be modified.
-     */
+    @Override
     public void getBounds(final PlanetModel planetModel, Bounds bounds) {
-      bounds.addPoint(point);
-      if (circlePlane == null)
-        return;
+      super.getBounds(planetModel, bounds);
       bounds.addPlane(planetModel, circlePlane);
     }
 
-    @Override
-    public boolean equals(Object o) {
-      if (!(o instanceof SegmentEndpoint))
-        return false;
-      SegmentEndpoint other = (SegmentEndpoint) o;
-      return point.equals(other.point);
-    }
-
-    @Override
-    public int hashCode() {
-      return point.hashCode();
-    }
-
-    @Override
-    public String toString() {
-      return point.toString();
-    }
   }
-
+  
   /**
    * This is the pre-calculated data for a path segment.
    */
@@ -1118,6 +1303,11 @@ class GeoStandardPath extends GeoBasePath {
     public boolean intersects(final PlanetModel planetModel, final Plane p, final GeoPoint[] notablePoints, final Membership[] bounds) {
       return upperConnectingPlane.intersects(planetModel, p, notablePoints, upperConnectingPlanePoints, bounds, lowerConnectingPlane, startCutoffPlane, endCutoffPlane) ||
           lowerConnectingPlane.intersects(planetModel, p, notablePoints, lowerConnectingPlanePoints, bounds, upperConnectingPlane, startCutoffPlane, endCutoffPlane);
+          /* ||
+          // These two are necessary because our segment endpoints are not necessarily good fits to their adjoining segments.  The checks should really be part of the segment endpoint, however
+          startCutoffPlane.intersects(planetModel, p, notablePoints, startCutoffPlanePoints, bounds, endCutoffPlane, upperConnectingPlane, lowerConnectingPlane) ||
+          endCutoffPlane.intersects(planetModel, p, notablePoints, endCutoffPlanePoints, bounds, startCutoffPlane, upperConnectingPlane, lowerConnectingPlane);
+              */
     }
 
     /** Determine if this endpoint intersects a specified GeoShape.
@@ -1127,6 +1317,11 @@ class GeoStandardPath extends GeoBasePath {
     public boolean intersects(final GeoShape geoShape) {
       return geoShape.intersects(upperConnectingPlane, upperConnectingPlanePoints, lowerConnectingPlane, startCutoffPlane, endCutoffPlane) ||
           geoShape.intersects(lowerConnectingPlane, lowerConnectingPlanePoints, upperConnectingPlane, startCutoffPlane, endCutoffPlane);
+          /*||
+          // These two are necessary because our segment endpoints are not necessarily good fits to their adjoining segments.  The checks should really be part of the segment endpoint, however
+          geoShape.intersects(startCutoffPlane, startCutoffPlanePoints, endCutoffPlane, upperConnectingPlane, lowerConnectingPlane) ||
+          geoShape.intersects(endCutoffPlane, endCutoffPlanePoints, startCutoffPlane, upperConnectingPlane, lowerConnectingPlane);
+              */
     }
 
     /** Get the bounds for a segment endpoint.
diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPathTest.java b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPathTest.java
index 27f83a1..cf42c14 100755
--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPathTest.java
+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPathTest.java
@@ -411,6 +411,8 @@ public class GeoPathTest extends LuceneTestCase {
     points[3] = new GeoPoint(PlanetModel.WGS84, -0.7718789008737459, 0.9236607495528212);
     GeoPath path  = GeoPathFactory.makeGeoPath(PlanetModel.WGS84, 1.3439035240356338, points);
     GeoPoint check = new GeoPoint(0.02071783020158524, 0.9523290535474472, 0.30699177256064203);
+    // Map to surface point, to remove that source of confusion
+    GeoPoint surfaceCheck = PlanetModel.WGS84.createSurfacePoint(check);
     /*
    [junit4]   1>   cycle: cell=12502 parentCellID=12500 x: -1658490249 TO 2147483041, y: 2042111310 TO 2147483041, z: -2140282940 TO 2140277970, splits: 1 queue.size()=1
    [junit4]   1>     minx=-0.7731590077686981 maxx=1.0011188539924791 miny=0.9519964046486451 maxy=1.0011188539924791 minz=-0.9977622932859775 maxz=0.9977599768255027
@@ -421,15 +423,14 @@ public class GeoPathTest extends LuceneTestCase {
       0.9519964046486451, 1.0011188539924791,
       -0.9977622932859775, 0.9977599768255027);
     // Verify that the point is within it
-    assertTrue(solid.isWithin(check));
-    // Check the relationship
+    assertTrue(solid.isWithin(surfaceCheck));
+    // Check the (surface) relationship
     int relationship = solid.getRelationship(path);
-    assertTrue(relationship == GeoArea.CONTAINS);
-    // If relationship is CONTAINS then any point in the solid must also be within the path
-    // If point is within solid, it must be within shape
-    assertTrue(path.isWithin(check));
-
-    //GeoPoint surfaceCheck = PlanetModel.WGS84.createSurfacePoint(check);
+    if (relationship == GeoArea.CONTAINS) {
+      // If relationship is CONTAINS then any point in the solid must also be within the path
+      // If point is within solid, it must be within shape
+      assertTrue(path.isWithin(surfaceCheck));
+    }
     
   }