lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kwri...@apache.org
Subject [23/26] lucene-solr:master: Finish debugging simple case
Date Fri, 29 Apr 2016 00:02:55 GMT
Finish debugging simple case


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/da896f80
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/da896f80
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/da896f80

Branch: refs/heads/master
Commit: da896f803dcaf2eb5dc1753eda05c7499b07e0c6
Parents: 3d7fd5e
Author: Karl Wright <DaddyWri@gmail.com>
Authored: Thu Apr 28 19:20:03 2016 -0400
Committer: Karl Wright <DaddyWri@gmail.com>
Committed: Thu Apr 28 19:20:03 2016 -0400

----------------------------------------------------------------------
 .../spatial3d/geom/GeoComplexPolygon.java       | 217 ++++++++++---------
 .../lucene/spatial3d/geom/GeoPolygonTest.java   |   3 -
 2 files changed, 117 insertions(+), 103 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/da896f80/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
----------------------------------------------------------------------
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
index c218776..661953a 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
@@ -40,15 +40,15 @@ class GeoComplexPolygon extends GeoBasePolygon {
   private final boolean testPointInSet;
   private final GeoPoint testPoint;
   
-  private final Plane testPointXZPlane;
-  private final Plane testPointXZAbovePlane;
-  private final Plane testPointXZBelowPlane;
-  private final Plane testPointYZPlane;
-  private final Plane testPointYZAbovePlane;
-  private final Plane testPointYZBelowPlane;
-  private final Plane testPointXYPlane;
-  private final Plane testPointXYAbovePlane;
-  private final Plane testPointXYBelowPlane;
+  private final Plane testPointFixedYPlane;
+  private final Plane testPointFixedYAbovePlane;
+  private final Plane testPointFixedYBelowPlane;
+  private final Plane testPointFixedXPlane;
+  private final Plane testPointFixedXAbovePlane;
+  private final Plane testPointFixedXBelowPlane;
+  private final Plane testPointFixedZPlane;
+  private final Plane testPointFixedZAbovePlane;
+  private final Plane testPointFixedZBelowPlane;
   
   private final GeoPoint[] edgePoints;
   private final Edge[] shapeStartEdges;
@@ -69,16 +69,16 @@ class GeoComplexPolygon extends GeoBasePolygon {
     this.testPointInSet = testPointInSet;
     this.testPoint = testPoint;
     
-    this.testPointXZPlane = new Plane(0.0, 1.0, 0.0, -testPoint.y);
-    this.testPointYZPlane = new Plane(1.0, 0.0, 0.0, -testPoint.x);
-    this.testPointXYPlane = new Plane(0.0, 0.0, 1.0, -testPoint.z);
+    this.testPointFixedYPlane = new Plane(0.0, 1.0, 0.0, -testPoint.y);
+    this.testPointFixedXPlane = new Plane(1.0, 0.0, 0.0, -testPoint.x);
+    this.testPointFixedZPlane = new Plane(0.0, 0.0, 1.0, -testPoint.z);
     
-    this.testPointXZAbovePlane = new Plane(testPointXZPlane, true);
-    this.testPointXZBelowPlane = new Plane(testPointXZPlane, false);
-    this.testPointYZAbovePlane = new Plane(testPointYZPlane, true);
-    this.testPointYZBelowPlane = new Plane(testPointYZPlane, false);
-    this.testPointXYAbovePlane = new Plane(testPointXYPlane, true);
-    this.testPointXYBelowPlane = new Plane(testPointXYPlane, false);
+    this.testPointFixedYAbovePlane = new Plane(testPointFixedYPlane, true);
+    this.testPointFixedYBelowPlane = new Plane(testPointFixedYPlane, false);
+    this.testPointFixedXAbovePlane = new Plane(testPointFixedXPlane, true);
+    this.testPointFixedXBelowPlane = new Plane(testPointFixedXPlane, false);
+    this.testPointFixedZAbovePlane = new Plane(testPointFixedZPlane, true);
+    this.testPointFixedZBelowPlane = new Plane(testPointFixedZPlane, false);
 
     this.edgePoints = new GeoPoint[pointsList.size()];
     this.shapeStartEdges = new Edge[pointsList.size()];
@@ -124,27 +124,27 @@ class GeoComplexPolygon extends GeoBasePolygon {
     }
     
     // If we're right on top of any of the test planes, we navigate solely on that plane.
-    if (testPointXZPlane.evaluateIsZero(thePoint)) {
+    if (testPointFixedYPlane.evaluateIsZero(thePoint)) {
       // Use the XZ plane exclusively.
-      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointXZPlane,
testPointXZAbovePlane, testPointXZBelowPlane, testPoint, thePoint);
+      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointFixedYPlane,
testPointFixedYAbovePlane, testPointFixedYBelowPlane, testPoint, thePoint);
       // Traverse our way from the test point to the check point.  Use the y tree because
that's fixed.
       if (!yTree.traverse(crossingEdgeIterator, testPoint.y)) {
         // Endpoint is on edge
         return true;
       }
       return ((crossingEdgeIterator.crossingCount & 1) == 0)?testPointInSet:!testPointInSet;
-    } else if (testPointYZPlane.evaluateIsZero(thePoint)) {
+    } else if (testPointFixedXPlane.evaluateIsZero(thePoint)) {
       // Use the YZ plane exclusively.
-      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointYZPlane,
testPointYZAbovePlane, testPointYZBelowPlane, testPoint, thePoint);
+      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointFixedXPlane,
testPointFixedXAbovePlane, testPointFixedXBelowPlane, testPoint, thePoint);
       // Traverse our way from the test point to the check point.  Use the x tree because
that's fixed.
       if (!xTree.traverse(crossingEdgeIterator, testPoint.x)) {
         // Endpoint is on edge
         return true;
       }
       return ((crossingEdgeIterator.crossingCount & 1) == 0)?testPointInSet:!testPointInSet;
-    } else if (testPointXYPlane.evaluateIsZero(thePoint)) {
+    } else if (testPointFixedZPlane.evaluateIsZero(thePoint)) {
       // Use the XY plane exclusively.
-      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointXYPlane,
testPointXYAbovePlane, testPointXYBelowPlane, testPoint, thePoint);
+      final LinearCrossingEdgeIterator crossingEdgeIterator = new LinearCrossingEdgeIterator(testPointFixedZPlane,
testPointFixedZAbovePlane, testPointFixedZBelowPlane, testPoint, thePoint);
       // Traverse our way from the test point to the check point.  Use the z tree because
that's fixed.
       if (!zTree.traverse(crossingEdgeIterator, testPoint.z)) {
         // Endpoint is on edge
@@ -153,20 +153,18 @@ class GeoComplexPolygon extends GeoBasePolygon {
       return ((crossingEdgeIterator.crossingCount & 1) == 0)?testPointInSet:!testPointInSet;
     } else {
       
-      System.err.println("isWithin() for check point "+thePoint+", test point "+testPoint);
-      
       // We need to use two planes to get there.  We don't know which two planes will do
it but we can figure it out.
       final Plane travelPlaneFixedX = new Plane(1.0, 0.0, 0.0, -thePoint.x);
       final Plane travelPlaneFixedY = new Plane(0.0, 1.0, 0.0, -thePoint.y);
       final Plane travelPlaneFixedZ = new Plane(0.0, 0.0, 1.0, -thePoint.z);
 
       // Find the intersection points for each one of these and the complementary test point
planes.
-      final GeoPoint[] XZIntersectionsYZ = travelPlaneFixedX.findIntersections(planetModel,
testPointYZPlane);
-      final GeoPoint[] XZIntersectionsXY = travelPlaneFixedX.findIntersections(planetModel,
testPointXYPlane);
-      final GeoPoint[] YZIntersectionsXZ = travelPlaneFixedY.findIntersections(planetModel,
testPointXZPlane);
-      final GeoPoint[] YZIntersectionsXY = travelPlaneFixedY.findIntersections(planetModel,
testPointXYPlane);
-      final GeoPoint[] XYIntersectionsYZ = travelPlaneFixedZ.findIntersections(planetModel,
testPointYZPlane);
-      final GeoPoint[] XYIntersectionsXZ = travelPlaneFixedZ.findIntersections(planetModel,
testPointXZPlane);
+      final GeoPoint[] XIntersectionsY = travelPlaneFixedX.findIntersections(planetModel,
testPointFixedYPlane);
+      final GeoPoint[] XIntersectionsZ = travelPlaneFixedX.findIntersections(planetModel,
testPointFixedZPlane);
+      final GeoPoint[] YIntersectionsX = travelPlaneFixedY.findIntersections(planetModel,
testPointFixedXPlane);
+      final GeoPoint[] YIntersectionsZ = travelPlaneFixedY.findIntersections(planetModel,
testPointFixedZPlane);
+      final GeoPoint[] ZIntersectionsX = travelPlaneFixedZ.findIntersections(planetModel,
testPointFixedXPlane);
+      final GeoPoint[] ZIntersectionsY = travelPlaneFixedZ.findIntersections(planetModel,
testPointFixedYPlane);
 
       // There will be multiple intersection points found.  We choose the one that has the
lowest total distance, as measured in delta X, delta Y, and delta Z.
       double bestDistance = Double.MAX_VALUE;
@@ -180,107 +178,106 @@ class GeoComplexPolygon extends GeoBasePolygon {
       Tree secondLegTree = null;
       GeoPoint intersectionPoint = null;
       
-      for (final GeoPoint p : XZIntersectionsYZ) {
-        // Travel would be in XZ plane (fixed y) then in YZ (fixed x)
-        final double newDistance = Math.abs(testPoint.y - p.y) + Math.abs(thePoint.x - p.x);
+      for (final GeoPoint p : XIntersectionsY) {
+        // Travel would be in YZ plane (fixed x) then in XZ (fixed y)
+        final double newDistance = Math.abs(testPoint.x - p.x) + Math.abs(thePoint.y - p.y);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
           firstLegValue = testPoint.y;
           secondLegValue = thePoint.x;
-          firstLegPlane = testPointXZPlane;
-          firstLegAbovePlane = testPointXZAbovePlane;
-          firstLegBelowPlane = testPointXZBelowPlane;
+          firstLegPlane = testPointFixedYPlane;
+          firstLegAbovePlane = testPointFixedYAbovePlane;
+          firstLegBelowPlane = testPointFixedYBelowPlane;
           secondLegPlane = travelPlaneFixedX;
           firstLegTree = yTree;
           secondLegTree = xTree;
           intersectionPoint = p;
         }
       }
-      for (final GeoPoint p : XZIntersectionsXY) {
-        // Travel would be in XZ plane (fixed y) then in XY (fixed z)
-        final double newDistance = Math.abs(testPoint.y - p.y) + Math.abs(thePoint.z - p.z);
+      for (final GeoPoint p : XIntersectionsZ) {
+        // Travel would be in YZ plane (fixed x) then in XY (fixed z)
+        final double newDistance = Math.abs(testPoint.x - p.x) + Math.abs(thePoint.z - p.z);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
-          firstLegValue = testPoint.y;
-          secondLegValue = thePoint.z;
-          firstLegPlane = testPointXZPlane;
-          firstLegAbovePlane = testPointXZAbovePlane;
-          firstLegBelowPlane = testPointXZBelowPlane;
-          secondLegPlane = travelPlaneFixedZ;
-          firstLegTree = yTree;
-          secondLegTree = zTree;
+          firstLegValue = testPoint.z;
+          secondLegValue = thePoint.x;
+          firstLegPlane = testPointFixedZPlane;
+          firstLegAbovePlane = testPointFixedZAbovePlane;
+          firstLegBelowPlane = testPointFixedZBelowPlane;
+          secondLegPlane = travelPlaneFixedX;
+          firstLegTree = zTree;
+          secondLegTree = xTree;
           intersectionPoint = p;
         }
       }
-      for (final GeoPoint p : YZIntersectionsXZ) {
-        // Travel would be in YZ plane (fixed x) then in XZ (fixed y)
-        final double newDistance = Math.abs(testPoint.x - p.x) + Math.abs(thePoint.y - p.y);
+      for (final GeoPoint p : YIntersectionsX) {
+        // Travel would be in XZ plane (fixed y) then in YZ (fixed x)
+        final double newDistance = Math.abs(testPoint.y - p.y) + Math.abs(thePoint.x - p.x);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
           firstLegValue = testPoint.x;
           secondLegValue = thePoint.y;
-          firstLegPlane = testPointYZPlane;
-          firstLegAbovePlane = testPointYZAbovePlane;
-          firstLegBelowPlane = testPointYZBelowPlane;
+          firstLegPlane = testPointFixedXPlane;
+          firstLegAbovePlane = testPointFixedXAbovePlane;
+          firstLegBelowPlane = testPointFixedXBelowPlane;
           secondLegPlane = travelPlaneFixedY;
           firstLegTree = xTree;
           secondLegTree = yTree;
           intersectionPoint = p;
         }
       }
-      for (final GeoPoint p : YZIntersectionsXY) {
-        // Travel would be in YZ plane (fixed x) then in XY (fixed z)
-        final double newDistance = Math.abs(testPoint.x - p.x) + Math.abs(thePoint.z - p.z);
+      for (final GeoPoint p : YIntersectionsZ) {
+        // Travel would be in XZ plane (fixed y) then in XY (fixed z)
+        final double newDistance = Math.abs(testPoint.y - p.y) + Math.abs(thePoint.z - p.z);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
-          firstLegValue = testPoint.x;
-          secondLegValue = thePoint.z;
-          firstLegPlane = testPointYZPlane;
-          firstLegAbovePlane = testPointYZAbovePlane;
-          firstLegBelowPlane = testPointYZBelowPlane;
-          secondLegPlane = travelPlaneFixedZ;
-          firstLegTree = xTree;
-          secondLegTree = zTree;
+          firstLegValue = testPoint.z;
+          secondLegValue = thePoint.y;
+          firstLegPlane = testPointFixedZPlane;
+          firstLegAbovePlane = testPointFixedZAbovePlane;
+          firstLegBelowPlane = testPointFixedZBelowPlane;
+          secondLegPlane = travelPlaneFixedY;
+          firstLegTree = zTree;
+          secondLegTree = yTree;
           intersectionPoint = p;
         }
       }
-      for (final GeoPoint p : XYIntersectionsYZ) {
+      for (final GeoPoint p : ZIntersectionsX) {
         // Travel would be in XY plane (fixed z) then in YZ (fixed x)
         final double newDistance = Math.abs(testPoint.z - p.z) + Math.abs(thePoint.x - p.x);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
-          firstLegValue = testPoint.z;
-          secondLegValue = thePoint.x;
-          firstLegPlane = testPointXYPlane;
-          firstLegAbovePlane = testPointXYAbovePlane;
-          firstLegBelowPlane = testPointXYBelowPlane;
-          secondLegPlane = travelPlaneFixedX;
-          firstLegTree = zTree;
-          secondLegTree = xTree;
+          firstLegValue = testPoint.x;
+          secondLegValue = thePoint.z;
+          firstLegPlane = testPointFixedXPlane;
+          firstLegAbovePlane = testPointFixedXAbovePlane;
+          firstLegBelowPlane = testPointFixedXBelowPlane;
+          secondLegPlane = travelPlaneFixedZ;
+          firstLegTree = xTree;
+          secondLegTree = zTree;
           intersectionPoint = p;
         }
       }
-      for (final GeoPoint p : XYIntersectionsXZ) {
+      for (final GeoPoint p : ZIntersectionsY) {
         // Travel would be in XY plane (fixed z) then in XZ (fixed y)
         final double newDistance = Math.abs(testPoint.z - p.z) + Math.abs(thePoint.y - p.y);
         if (newDistance < bestDistance) {
           bestDistance = newDistance;
-          firstLegValue = testPoint.z;
-          secondLegValue = thePoint.y;
-          firstLegPlane = testPointXYPlane;
-          firstLegAbovePlane = testPointXYAbovePlane;
-          firstLegBelowPlane = testPointXYBelowPlane;
-          secondLegPlane = travelPlaneFixedY;
-          firstLegTree = zTree;
-          secondLegTree = yTree;
+          firstLegValue = testPoint.y;
+          secondLegValue = thePoint.z;
+          firstLegPlane = testPointFixedYPlane;
+          firstLegAbovePlane = testPointFixedYAbovePlane;
+          firstLegBelowPlane = testPointFixedYBelowPlane;
+          secondLegPlane = travelPlaneFixedZ;
+          firstLegTree = yTree;
+          secondLegTree = zTree;
           intersectionPoint = p;
         }
       }
 
+      assert bestDistance > 0.0 : "Best distance should not be zero unless on single plane";
       assert bestDistance < Double.MAX_VALUE : "Couldn't find an intersection point of
any kind";
       
-      System.err.println("Best distance: "+bestDistance);
-      
       final DualCrossingEdgeIterator edgeIterator = new DualCrossingEdgeIterator(firstLegPlane,
firstLegAbovePlane, firstLegBelowPlane, secondLegPlane, testPoint, thePoint, intersectionPoint);
       if (!firstLegTree.traverse(edgeIterator, firstLegValue)) {
         return true;
@@ -392,7 +389,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
       this.planeBounds.addPoint(startPoint);
       this.planeBounds.addPoint(endPoint);
       this.plane.recordBounds(pm, this.planeBounds, this.startPlane, this.endPlane);
-      System.err.println("Recording edge "+this+" from "+startPoint+" to "+endPoint+"; bounds
= "+planeBounds);
+      //System.err.println("Recording edge "+this+" from "+startPoint+" to "+endPoint+";
bounds = "+planeBounds);
     }
   }
   
@@ -632,12 +629,14 @@ class GeoComplexPolygon extends GeoBasePolygon {
     public ZTree() {
     }
     
+    /*
     @Override
     public boolean traverse(final EdgeIterator edgeIterator, final double value) {
       System.err.println("Traversing in Z, value= "+value+"...");
       return super.traverse(edgeIterator, value);
     }
-
+    */
+    
     @Override
     protected double getMinimum(final Edge edge) {
       return edge.planeBounds.getMinimumZ();
@@ -657,11 +656,13 @@ class GeoComplexPolygon extends GeoBasePolygon {
     public YTree() {
     }
 
+    /*
     @Override
     public boolean traverse(final EdgeIterator edgeIterator, final double value) {
       System.err.println("Traversing in Y, value= "+value+"...");
       return super.traverse(edgeIterator, value);
     }
+    */
     
     @Override
     protected double getMinimum(final Edge edge) {
@@ -682,11 +683,13 @@ class GeoComplexPolygon extends GeoBasePolygon {
     public XTree() {
     }
     
+    /*
     @Override
     public boolean traverse(final EdgeIterator edgeIterator, final double value) {
       System.err.println("Traversing in X, value= "+value+"...");
       return super.traverse(edgeIterator, value);
     }
+    */
     
     @Override
     protected double getMinimum(final Edge edge) {
@@ -909,6 +912,11 @@ class GeoComplexPolygon extends GeoBasePolygon {
       this.thePoint = thePoint;
       this.intersectionPoint = intersectionPoint;
       
+      //System.err.println("Intersection point = "+intersectionPoint);
+        
+      assert travelPlane.evaluateIsZero(intersectionPoint) : "intersection point must be
on travel plane";
+      assert testPointPlane.evaluateIsZero(intersectionPoint) : "intersection point must
be on test point plane";
+        
       assert !testPoint.isNumericallyIdentical(intersectionPoint) : "test point is the same
as intersection point";
       assert !thePoint.isNumericallyIdentical(intersectionPoint) : "check point is same is
intersection point";
 
@@ -981,10 +989,10 @@ class GeoComplexPolygon extends GeoBasePolygon {
     
     @Override
     public boolean matches(final Edge edge) {
-      System.err.println("Processing edge "+edge+", startpoint="+edge.startPoint+" endpoint="+edge.endPoint);
+      //System.err.println("Processing edge "+edge+", startpoint="+edge.startPoint+" endpoint="+edge.endPoint);
       // Early exit if the point is on the edge.
       if (thePoint != null && edge.plane.evaluateIsZero(thePoint) && edge.startPlane.isWithin(thePoint)
&& edge.endPlane.isWithin(thePoint)) {
-        System.err.println(" Check point is on edge: isWithin = true");
+        //System.err.println(" Check point is on edge: isWithin = true");
         return false;
       }
       // If the intersection point lies on this edge, we should still be able to consider
crossing points only.
@@ -992,10 +1000,10 @@ class GeoComplexPolygon extends GeoBasePolygon {
       // for at least one of the two planes in order to be a legitimate crossing of the combined
path.
       final GeoPoint[] crossingPoints;
       if (isSecondLeg) {
-        System.err.println(" check point plane = "+travelPlane);
+        //System.err.println(" check point plane = "+travelPlane);
         crossingPoints = travelPlane.findCrossings(planetModel, edge.plane, checkPointCutoffPlane,
checkPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
       } else {
-        System.err.println(" test point plane = "+testPointPlane);
+        //System.err.println(" test point plane = "+testPointPlane);
         crossingPoints = testPointPlane.findCrossings(planetModel, edge.plane, testPointCutoffPlane,
testPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
       }
       if (crossingPoints != null) {
@@ -1003,15 +1011,15 @@ class GeoComplexPolygon extends GeoBasePolygon {
         for (final GeoPoint crossingPoint : crossingPoints) {
           countCrossingPoint(crossingPoint, edge);
         }
-        System.err.println(" All crossing points processed");
+        //System.err.println(" All crossing points processed");
       } else {
-        System.err.println(" No crossing points!");
+        //System.err.println(" No crossing points!");
       }
       return true;
     }
 
     private void countCrossingPoint(final GeoPoint crossingPoint, final Edge edge) {
-      System.err.println(" Crossing point "+crossingPoint);
+      //System.err.println(" Crossing point "+crossingPoint);
       // We consider crossing points only in this method.
       // Unlike the linear case, there are additional cases when:
       // (1) The crossing point and the intersection point are the same, but are not the
endpoint of an edge;
@@ -1025,14 +1033,14 @@ class GeoComplexPolygon extends GeoBasePolygon {
       // In either case, we have to be sure to count each edge only once, since it might
appear in both the
       // first leg and the second.  If the first leg can process it, it should, and the second
should skip it.
       if (crossingPoint.isNumericallyIdentical(intersectionPoint)) {
-        System.err.println(" Crosses intersection point.");
+        //System.err.println(" Crosses intersection point.");
         if (isSecondLeg) {
           // See whether this edge would have been processed in the first leg; if so, we
skip it.
           final GeoPoint[] firstLegCrossings = testPointPlane.findCrossings(planetModel,
edge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
           for (final GeoPoint firstLegCrossing : firstLegCrossings) {
             if (firstLegCrossing.isNumericallyIdentical(intersectionPoint)) {
               // We already processed it, so we're done here.
-              System.err.println("  Already processed on previous leg: exit");
+              //System.err.println("  Already processed on previous leg: exit");
               return;
             }
           }
@@ -1061,7 +1069,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
       }
         
       if (crossingPoint.isNumericallyIdentical(edge.startPoint)) {
-        System.err.println(" Crossing point = edge.startPoint");
+        //System.err.println(" Crossing point = edge.startPoint");
         // We have to figure out if this crossing should be counted.
           
         // Does the crossing for this edge go up, or down?  Or can't we tell?
@@ -1073,6 +1081,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
         assert !(insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length
> 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length
> 0) : "edge that ends in a crossing can't both up and down";
           
         if (insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length
== 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length
== 0) {
+          //System.err.println(" No inside or outside crossings found");
           return;
         }
 
@@ -1117,6 +1126,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
             // Found it!
             // Both edges will try to contribute to the crossing count.  By convention, we'll
only include the earlier one.
             // Since we're the latter point, we exit here in that case.
+            //System.err.println(" Earlier point fired, so this one shouldn't");
             return;
           }
         }
@@ -1127,11 +1137,14 @@ class GeoComplexPolygon extends GeoBasePolygon {
           
         final boolean assessEdgeInside = assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length
> 0;
         if (assessEdgeInside != edgeCrossesInside) {
+          //System.err.println(" Incrementing crossing count");
           crossingCount++;
+        } else {
+          //System.err.println(" Entered and exited on same side");
         }
           
       } else if (crossingPoint.isNumericallyIdentical(edge.endPoint)) {
-        System.err.println(" Crossing point = edge.endPoint");
+        //System.err.println(" Crossing point = edge.endPoint");
         // Figure out if the crossing should be counted.
           
         // Does the crossing for this edge go up, or down?  Or can't we tell?
@@ -1144,6 +1157,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
         //assert !(insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length
> 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length
> 0) : "edge that ends in a crossing can't go both up and down: insideTestPointPlaneIntersections:
"+insideTestPointPlaneIntersections.length+" insideTravelPlaneIntersections: "+insideTravelPlaneIntersections.length+"
outsideTestPointPlaneIntersections: "+outsideTestPointPlaneIntersections.length+" outsideTravelPlaneIntersections:
"+outsideTravelPlaneIntersections.length;
           
         if (insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length
== 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length
== 0) {
+          //System.err.println(" No inside or outside crossings found");
           return;
         }
 
@@ -1183,10 +1197,13 @@ class GeoComplexPolygon extends GeoBasePolygon {
 
         final boolean assessEdgeInside = assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length
> 0;
         if (assessEdgeInside != edgeCrossesInside) {
+          //System.err.println(" Incrementing crossing count");
           crossingCount++;
+        } else {
+          //System.err.println(" Entered and exited on same side");
         }
       } else {
-        System.err.println(" Not a special case: incrementing crossing count");
+        //System.err.println(" Not a special case: incrementing crossing count");
         // Not a special case, so we can safely count a crossing.
         crossingCount++;
       }

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/da896f80/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPolygonTest.java
----------------------------------------------------------------------
diff --git a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPolygonTest.java
b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPolygonTest.java
index 53fc246..b325e43 100755
--- a/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPolygonTest.java
+++ b/lucene/spatial3d/src/test/org/apache/lucene/spatial3d/geom/GeoPolygonTest.java
@@ -189,9 +189,6 @@ public class GeoPolygonTest {
     shapes.add(new GeoPolygonFactory.PolygonDescription(points));
     
     c = GeoPolygonFactory.makeLargeGeoPolygon(PlanetModel.SPHERE, shapes);
-    gp = new GeoPoint(PlanetModel.SPHERE, 0.0, -0.35);
-    assertFalse(c.isWithin(gp));
-
     // Sample some points within
     gp = new GeoPoint(PlanetModel.SPHERE, 0.0, -0.45);
     assertTrue(c.isWithin(gp));


Mime
View raw message