LUCENE-8227: Redevelop path iterator implementations to make them robust against edges on paths.

This commit is contained in:
Karl Wright 2018-03-30 06:43:42 -04:00
parent 358e59596d
commit bc40f6c7e2
3 changed files with 231 additions and 497 deletions

View File

@ -19,6 +19,8 @@ package org.apache.lucene.spatial3d.geom;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.io.InputStream; import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.io.IOException; import java.io.IOException;
@ -157,6 +159,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
@Override @Override
public boolean isWithin(final double x, final double y, final double z) { public boolean isWithin(final double x, final double y, final double z) {
//System.out.println("\nIswithin called for ["+x+","+y+","+z+"]");
// If we're right on top of the point, we know the answer. // If we're right on top of the point, we know the answer.
if (testPoint.isNumericallyIdentical(x, y, z)) { if (testPoint.isNumericallyIdentical(x, y, z)) {
return testPointInSet; return testPointInSet;
@ -366,11 +369,12 @@ class GeoComplexPolygon extends GeoBasePolygon {
if (!firstLegTree.traverse(edgeIterator, firstLegValue)) { if (!firstLegTree.traverse(edgeIterator, firstLegValue)) {
return true; return true;
} }
edgeIterator.setSecondLeg(); //edgeIterator.setSecondLeg();
if (!secondLegTree.traverse(edgeIterator, secondLegValue)) { if (!secondLegTree.traverse(edgeIterator, secondLegValue)) {
return true; return true;
} }
return ((edgeIterator.crossingCount & 1) == 0)?testPointInSet:!testPointInSet; //System.out.println("Polarity vs. test point: "+(((edgeIterator.getCrossingCount() & 1) == 0)?"same":"different")+"; testPointInSet: "+testPointInSet);
return ((edgeIterator.getCrossingCount() & 1) == 0)?testPointInSet:!testPointInSet;
} }
} }
@ -502,6 +506,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
this.planeBounds.addPlane(pm, this.plane, this.startPlane, this.endPlane); this.planeBounds.addPlane(pm, this.plane, 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);
} }
// Hashcode and equals are system default!!
} }
/** /**
@ -798,7 +804,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
private final double thePointY; private final double thePointY;
private final double thePointZ; private final double thePointZ;
private int crossingCount = 0; private int aboveCrossingCount = 0;
private int belowCrossingCount = 0;
public FullLinearCrossingEdgeIterator(final Plane plane, final Plane abovePlane, final Plane belowPlane, final double thePointX, final double thePointY, final double thePointZ) { public FullLinearCrossingEdgeIterator(final Plane plane, final Plane abovePlane, final Plane belowPlane, final double thePointX, final double thePointY, final double thePointZ) {
this.plane = plane; this.plane = plane;
@ -813,7 +820,11 @@ class GeoComplexPolygon extends GeoBasePolygon {
@Override @Override
public int getCrossingCount() { public int getCrossingCount() {
return crossingCount; if (aboveCrossingCount < belowCrossingCount) {
return aboveCrossingCount;
} else {
return belowCrossingCount;
}
} }
@Override @Override
@ -822,131 +833,29 @@ class GeoComplexPolygon extends GeoBasePolygon {
if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) { if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) {
return false; return false;
} }
final GeoPoint[] crossingPoints = plane.findCrossings(planetModel, edge.plane, bound, edge.startPlane, edge.endPlane);
if (crossingPoints != null) { // This should precisely mirror what is in DualCrossingIterator, but without the dual crossings.
// We need to handle the endpoint case, which is quite tricky. // Some edges are going to be given to us even when there's no real intersection, so do that as a sanity check, first.
for (final GeoPoint crossingPoint : crossingPoints) { final GeoPoint[] planeCrossings = plane.findIntersections(planetModel, edge.plane, bound, edge.startPlane, edge.endPlane);
countCrossingPoint(crossingPoint, edge); if (planeCrossings != null && planeCrossings.length == 0) {
} // No actual crossing
return true;
} }
// Determine crossings of this edge against all inside/outside planes. There's no further need to look at the actual travel plane itself.
final GeoPoint[] aboveCrossings = abovePlane.findCrossings(planetModel, edge.plane, bound, edge.startPlane, edge.endPlane);
final GeoPoint[] belowCrossings = belowPlane.findCrossings(planetModel, edge.plane, bound, edge.startPlane, edge.endPlane);
if (aboveCrossings != null) {
aboveCrossingCount += aboveCrossings.length;
}
if (belowCrossings != null) {
belowCrossingCount += belowCrossings.length;
}
return true; return true;
} }
private void countCrossingPoint(final GeoPoint crossingPoint, final Edge edge) {
if (crossingPoint.isNumericallyIdentical(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?
final GeoPoint[] aboveIntersections = abovePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] belowIntersections = belowPlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
assert !(aboveIntersections.length > 0 && belowIntersections.length > 0) : "edge that ends in a crossing can't both up and down";
if (aboveIntersections.length == 0 && belowIntersections.length == 0) {
return;
}
final boolean edgeCrossesAbove = aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessAboveIntersections;
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.previous;
assessAboveIntersections = abovePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessBelowIntersections = belowPlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assert !(assessAboveIntersections.length > 0 && assessBelowIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
if (assessAboveIntersections.length == 0 && assessBelowIntersections.length == 0) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// To handle the latter situation, we need to know if the other edge will be looked at also, and then we can make
// a decision whether to count or not based on that.
// Compute the crossing points of this other edge.
final GeoPoint[] otherCrossingPoints = plane.findCrossings(planetModel, assessEdge.plane, bound, assessEdge.startPlane, assessEdge.endPlane);
// Look for a matching endpoint. If the other endpoint doesn't show up, it is either out of bounds (in which case the
// transition won't be counted for that edge), or it is not a crossing for that edge (so, same conclusion).
for (final GeoPoint otherCrossingPoint : otherCrossingPoints) {
if (otherCrossingPoint.isNumericallyIdentical(assessEdge.endPoint)) {
// 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.
return;
}
}
// Both edges will not count the same point, so we can proceed. We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeAbove = assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
} else if (crossingPoint.isNumericallyIdentical(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?
final GeoPoint[] aboveIntersections = abovePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] belowIntersections = belowPlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
assert !(aboveIntersections.length > 0 && belowIntersections.length > 0) : "edge that ends in a crossing can't both up and down";
if (aboveIntersections.length == 0 && belowIntersections.length == 0) {
return;
}
final boolean edgeCrossesAbove = aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessAboveIntersections;
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.next;
assessAboveIntersections = abovePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessBelowIntersections = belowPlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assert !(assessAboveIntersections.length > 0 && assessBelowIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
if (assessAboveIntersections.length == 0 && assessBelowIntersections.length == 0) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// By definition, we're the earlier plane in this case, so any crossing we detect we must count, by convention. It is unnecessary
// to consider what the other edge does, because when we get to it, it will look back and figure out what we did for this one.
// We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeAbove = assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
} else {
crossingCount++;
}
}
} }
/** Create a linear crossing edge iterator with the appropriate cutoff planes given the geometry. /** Create a linear crossing edge iterator with the appropriate cutoff planes given the geometry.
@ -980,7 +889,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
private final double thePointY; private final double thePointY;
private final double thePointZ; private final double thePointZ;
private int crossingCount = 0; private int aboveCrossingCount = 0;
private int belowCrossingCount = 0;
public SectorLinearCrossingEdgeIterator(final Plane plane, final Plane abovePlane, final Plane belowPlane, final double thePointX, final double thePointY, final double thePointZ) { public SectorLinearCrossingEdgeIterator(final Plane plane, final Plane abovePlane, final Plane belowPlane, final double thePointX, final double thePointY, final double thePointZ) {
this.plane = plane; this.plane = plane;
@ -996,7 +906,11 @@ class GeoComplexPolygon extends GeoBasePolygon {
@Override @Override
public int getCrossingCount() { public int getCrossingCount() {
return crossingCount; if (aboveCrossingCount < belowCrossingCount) {
return aboveCrossingCount;
} else {
return belowCrossingCount;
}
} }
@Override @Override
@ -1005,139 +919,38 @@ class GeoComplexPolygon extends GeoBasePolygon {
if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) { if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) {
return false; return false;
} }
final GeoPoint[] crossingPoints = plane.findCrossings(planetModel, edge.plane, bound1, bound2, edge.startPlane, edge.endPlane);
if (crossingPoints != null) { // This should precisely mirror what is in DualCrossingIterator, but without the dual crossings.
// We need to handle the endpoint case, which is quite tricky. // Some edges are going to be given to us even when there's no real intersection, so do that as a sanity check, first.
for (final GeoPoint crossingPoint : crossingPoints) { final GeoPoint[] planeCrossings = plane.findIntersections(planetModel, edge.plane, bound1, bound2, edge.startPlane, edge.endPlane);
countCrossingPoint(crossingPoint, edge); if (planeCrossings != null && planeCrossings.length == 0) {
} // No actual crossing
return true;
} }
// Determine crossings of this edge against all inside/outside planes. There's no further need to look at the actual travel plane itself.
final GeoPoint[] aboveCrossings = abovePlane.findCrossings(planetModel, edge.plane, bound1, bound2, edge.startPlane, edge.endPlane);
final GeoPoint[] belowCrossings = belowPlane.findCrossings(planetModel, edge.plane, bound1, bound2, edge.startPlane, edge.endPlane);
if (aboveCrossings != null) {
aboveCrossingCount += aboveCrossings.length;
}
if (belowCrossings != null) {
belowCrossingCount += belowCrossings.length;
}
return true; return true;
} }
private void countCrossingPoint(final GeoPoint crossingPoint, final Edge edge) {
if (crossingPoint.isNumericallyIdentical(edge.startPoint)) {
// The crossing point is shared by two edges. If we are going to count it, this is the edge we'll count it on.
// We have to figure out if this crossing should be counted.
// We look at the above plane and the below plane and see if we cross either of them.
// If we cross NEITHER of them: we're in the "zone" between the planes, and this edge doesn't count.
// Does the crossing for this edge go up, or down? Or can't we tell?
final GeoPoint[] aboveIntersections = abovePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] belowIntersections = belowPlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
if ((aboveIntersections == null || aboveIntersections.length == 0) && (belowIntersections == null || belowIntersections.length == 0)) {
return;
}
// A null value means we have a situation where the edge is numerically identical. That's not counted as a "crossing".
assert !(aboveIntersections != null && aboveIntersections.length > 0 && belowIntersections != null && belowIntersections.length > 0) : "edge that ends in a crossing can't be both up and down!";
final boolean edgeCrossesAbove = aboveIntersections != null && aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessAboveIntersections;
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.previous;
assessAboveIntersections = abovePlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessBelowIntersections = belowPlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
if ((assessAboveIntersections == null || assessAboveIntersections.length == 0) && (assessBelowIntersections == null || assessBelowIntersections.length == 0)) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// To handle the latter situation, we need to know if the other edge will be looked at also, and then we can make
// a decision whether to count or not based on that.
// Compute the crossing points of this other edge.
final GeoPoint[] otherCrossingPoints = plane.findCrossings(planetModel, assessEdge.plane, bound1, bound2, assessEdge.startPlane, assessEdge.endPlane);
// Look for a matching endpoint. If the other endpoint doesn't show up, it is either out of bounds (in which case the
// transition won't be counted for that edge), or it is not a crossing for that edge (so, same conclusion).
for (final GeoPoint otherCrossingPoint : otherCrossingPoints) {
if (otherCrossingPoint.isNumericallyIdentical(assessEdge.endPoint)) {
// 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.
return;
}
}
// Both edges will not count the same point, so we can proceed. We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeAbove = assessAboveIntersections != null && assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
} else if (crossingPoint.isNumericallyIdentical(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?
final GeoPoint[] aboveIntersections = abovePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] belowIntersections = belowPlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
if ((aboveIntersections == null || aboveIntersections.length == 0) && (belowIntersections == null || belowIntersections.length == 0)) {
return;
}
final boolean edgeCrossesAbove = aboveIntersections != null && aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessAboveIntersections;
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.next;
assessAboveIntersections = abovePlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessBelowIntersections = belowPlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
if (assessAboveIntersections != null && assessAboveIntersections.length == 0 && assessBelowIntersections != null && assessBelowIntersections.length == 0) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// By definition, we're the earlier plane in this case, so any crossing we detect we must count, by convention. It is unnecessary
// to consider what the other edge does, because when we get to it, it will look back and figure out what we did for this one.
// We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeAbove = assessAboveIntersections != null && assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
} else {
crossingCount++;
}
}
} }
/** Count the number of verifiable edge crossings for a dual-leg journey. /** Count the number of verifiable edge crossings for a dual-leg journey.
*/ */
private class DualCrossingEdgeIterator implements EdgeIterator { private class DualCrossingEdgeIterator implements EdgeIterator {
private boolean isSecondLeg = false; // This is a hash of which edges we've already looked at and tallied, so we don't repeat ourselves.
// It is lazily initialized since most transitions cross no edges at all.
private Set<Edge> seenEdges = null;
private final Plane testPointPlane; private final Plane testPointPlane;
private final Plane testPointAbovePlane; private final Plane testPointAbovePlane;
@ -1163,10 +976,12 @@ class GeoComplexPolygon extends GeoBasePolygon {
private Plane travelOutsidePlane; private Plane travelOutsidePlane;
private SidedPlane insideTestPointCutoffPlane; private SidedPlane insideTestPointCutoffPlane;
private SidedPlane insideTravelCutoffPlane; private SidedPlane insideTravelCutoffPlane;
private SidedPlane outsideTestPointCutoffPlane;
private SidedPlane outsideTravelCutoffPlane;
// The counter // The counters
public int innerCrossingCount = 0;
public int crossingCount = 0; public int outerCrossingCount = 0;
public DualCrossingEdgeIterator(final Plane testPointPlane, final Plane testPointAbovePlane, final Plane testPointBelowPlane, public DualCrossingEdgeIterator(final Plane testPointPlane, final Plane testPointAbovePlane, final Plane testPointBelowPlane,
final Plane travelPlane, final double thePointX, final double thePointY, final double thePointZ, final GeoPoint intersectionPoint) { final Plane travelPlane, final double thePointX, final double thePointY, final double thePointZ, final GeoPoint intersectionPoint) {
@ -1179,7 +994,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
this.thePointZ = thePointZ; this.thePointZ = thePointZ;
this.intersectionPoint = intersectionPoint; this.intersectionPoint = intersectionPoint;
//System.err.println("Intersection point = "+intersectionPoint); //System.out.println("Intersection point = "+intersectionPoint);
assert travelPlane.evaluateIsZero(intersectionPoint) : "intersection point must be on travel plane"; assert travelPlane.evaluateIsZero(intersectionPoint) : "intersection point must be on travel plane";
assert testPointPlane.evaluateIsZero(intersectionPoint) : "intersection point must be on test point plane"; assert testPointPlane.evaluateIsZero(intersectionPoint) : "intersection point must be on test point plane";
@ -1216,6 +1031,9 @@ class GeoComplexPolygon extends GeoBasePolygon {
final Plane travelAbovePlane = new Plane(travelPlane, true); final Plane travelAbovePlane = new Plane(travelPlane, true);
final Plane travelBelowPlane = new Plane(travelPlane, false); final Plane travelBelowPlane = new Plane(travelPlane, false);
// Each of these can generate two solutions. We need to refine them to generate only one somehow -- the one in the same area of the world as intersectionPoint.
// Since the travel/testpoint planes have one fixed coordinate, and that is represented by the plane's D value, it should be possible to choose based on the
// point's coordinates.
final GeoPoint[] aboveAbove = travelAbovePlane.findIntersections(planetModel, testPointAbovePlane, intersectionBound1, intersectionBound2); final GeoPoint[] aboveAbove = travelAbovePlane.findIntersections(planetModel, testPointAbovePlane, intersectionBound1, intersectionBound2);
assert aboveAbove != null : "Above + above should not be coplanar"; assert aboveAbove != null : "Above + above should not be coplanar";
final GeoPoint[] aboveBelow = travelAbovePlane.findIntersections(planetModel, testPointBelowPlane, intersectionBound1, intersectionBound2); final GeoPoint[] aboveBelow = travelAbovePlane.findIntersections(planetModel, testPointBelowPlane, intersectionBound1, intersectionBound2);
@ -1227,265 +1045,197 @@ class GeoComplexPolygon extends GeoBasePolygon {
assert ((aboveAbove.length > 0)?1:0) + ((aboveBelow.length > 0)?1:0) + ((belowBelow.length > 0)?1:0) + ((belowAbove.length > 0)?1:0) == 1 : "Can be exactly one inside point, instead was: aa="+aboveAbove.length+" ab=" + aboveBelow.length+" bb="+ belowBelow.length+" ba=" + belowAbove.length; assert ((aboveAbove.length > 0)?1:0) + ((aboveBelow.length > 0)?1:0) + ((belowBelow.length > 0)?1:0) + ((belowAbove.length > 0)?1:0) == 1 : "Can be exactly one inside point, instead was: aa="+aboveAbove.length+" ab=" + aboveBelow.length+" bb="+ belowBelow.length+" ba=" + belowAbove.length;
final GeoPoint[] insideInsidePoints;
if (aboveAbove.length > 0) { if (aboveAbove.length > 0) {
travelInsidePlane = travelAbovePlane; travelInsidePlane = travelAbovePlane;
testPointInsidePlane = testPointAbovePlane; testPointInsidePlane = testPointAbovePlane;
travelOutsidePlane = travelBelowPlane; travelOutsidePlane = travelBelowPlane;
testPointOutsidePlane = testPointBelowPlane; testPointOutsidePlane = testPointBelowPlane;
insideInsidePoints = aboveAbove;
} else if (aboveBelow.length > 0) { } else if (aboveBelow.length > 0) {
travelInsidePlane = travelAbovePlane; travelInsidePlane = travelAbovePlane;
testPointInsidePlane = testPointBelowPlane; testPointInsidePlane = testPointBelowPlane;
travelOutsidePlane = travelBelowPlane; travelOutsidePlane = travelBelowPlane;
testPointOutsidePlane = testPointAbovePlane; testPointOutsidePlane = testPointAbovePlane;
insideInsidePoints = aboveBelow;
} else if (belowBelow.length > 0) { } else if (belowBelow.length > 0) {
travelInsidePlane = travelBelowPlane; travelInsidePlane = travelBelowPlane;
testPointInsidePlane = testPointBelowPlane; testPointInsidePlane = testPointBelowPlane;
travelOutsidePlane = travelAbovePlane; travelOutsidePlane = travelAbovePlane;
testPointOutsidePlane = testPointAbovePlane; testPointOutsidePlane = testPointAbovePlane;
insideInsidePoints = belowBelow;
} else { } else {
travelInsidePlane = travelBelowPlane; travelInsidePlane = travelBelowPlane;
testPointInsidePlane = testPointAbovePlane; testPointInsidePlane = testPointAbovePlane;
travelOutsidePlane = travelAbovePlane; travelOutsidePlane = travelAbovePlane;
testPointOutsidePlane = testPointBelowPlane; testPointOutsidePlane = testPointBelowPlane;
insideInsidePoints = belowAbove;
} }
insideTravelCutoffPlane = new SidedPlane(thePointX, thePointY, thePointZ, testPointInsidePlane, testPointInsidePlane.D); // Get the inside-inside intersection point
insideTestPointCutoffPlane = new SidedPlane(testPoint, travelInsidePlane, travelInsidePlane.D); // Picking which point, out of two, that corresponds to the already-selected intersectionPoint, is tricky, but it must be done.
// We expect the choice to be within a small delta of the intersection point in 2 of the dimensions, but not the third
final GeoPoint insideInsidePoint = pickProximate(insideInsidePoints);
// Get the outside-outside intersection point
final GeoPoint[] outsideOutsidePoints = testPointOutsidePlane.findIntersections(planetModel, travelOutsidePlane); //these don't add anything: , checkPointCutoffPlane, testPointCutoffPlane);
final GeoPoint outsideOutsidePoint = pickProximate(outsideOutsidePoints);
insideTravelCutoffPlane = new SidedPlane(thePointX, thePointY, thePointZ, travelInsidePlane, insideInsidePoint);
outsideTravelCutoffPlane = new SidedPlane(thePointX, thePointY, thePointZ, travelInsidePlane, outsideOutsidePoint);
insideTestPointCutoffPlane = new SidedPlane(testPoint, testPointInsidePlane, insideInsidePoint);
outsideTestPointCutoffPlane = new SidedPlane(testPoint, testPointOutsidePlane, outsideOutsidePoint);
/*
System.out.println("insideTravelCutoffPlane = "+insideTravelCutoffPlane);
System.out.println("outsideTravelCutoffPlane = "+outsideTravelCutoffPlane);
System.out.println("insideTestPointCutoffPlane = "+insideTestPointCutoffPlane);
System.out.println("outsideTestPointCutoffPlane = "+outsideTestPointCutoffPlane);
*/
computedInsideOutside = true; computedInsideOutside = true;
} }
} }
public void setSecondLeg() { private GeoPoint pickProximate(final GeoPoint[] points) {
isSecondLeg = true; if (points.length == 0) {
throw new IllegalArgumentException("No off-plane intersection points were found; can't compute traversal");
} else if (points.length == 1) {
return points[0];
} else {
final double p1dist = computeSquaredDistance(points[0], intersectionPoint);
final double p2dist = computeSquaredDistance(points[1], intersectionPoint);
if (p1dist < p2dist) {
return points[0];
} else if (p2dist < p1dist) {
return points[1];
} else {
throw new IllegalArgumentException("Neither off-plane intersection point matched intersection point; intersection = "+intersectionPoint+"; offplane choice 0: "+points[0]+"; offplane choice 1: "+points[1]);
}
}
}
public int getCrossingCount() {
// Doesn't return the actual crossing count -- just gets the even/odd part right
if (innerCrossingCount < outerCrossingCount) {
return innerCrossingCount;
} else {
return outerCrossingCount;
}
} }
@Override @Override
public boolean matches(final Edge edge) { public boolean matches(final Edge edge) {
//System.err.println("Processing edge "+edge+", startpoint="+edge.startPoint+" endpoint="+edge.endPoint); // Early exit if the point is on the edge, in which case we accidentally discovered the answer.
// Early exit if the point is on the edge.
if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) { if (edge.plane.evaluateIsZero(thePointX, thePointY, thePointZ) && edge.startPlane.isWithin(thePointX, thePointY, thePointZ) && edge.endPlane.isWithin(thePointX, thePointY, thePointZ)) {
//System.err.println(" Check point is on edge: isWithin = true");
return false; return false;
} }
// If the intersection point lies on this edge, we should still be able to consider crossing points only.
// Even if an intersection point is eliminated because it's not a crossing of one plane, it will have to be a crossing // All edges that touch the travel planes get assessed the same. So, for each intersecting edge on both legs:
// for at least one of the two planes in order to be a legitimate crossing of the combined path. // (1) If the edge contains the intersection point, we analyze it on only one leg. For the other leg, we do nothing.
final GeoPoint[] crossingPoints; // (2) We compute the crossings of the edge with ALL FOUR inner and outer bounding planes.
if (isSecondLeg) { // (3) We add the numbers of each kind of crossing to the total for that class of crossing (innerTotal and outerTotal).
//System.err.println(" check point plane = "+travelPlane); // (4) When done all edges tallied in this way, we take min(innerTotal, outerTotal) and assume that is the number of crossings.
crossingPoints = travelPlane.findCrossings(planetModel, edge.plane, checkPointCutoffPlane, checkPointOtherCutoffPlane, edge.startPlane, edge.endPlane); //
} else { // Q: What if we see the same edge in both traversals?
//System.err.println(" test point plane = "+testPointPlane); // A: We should really evaluate it only in one. Keep a hash of the edges we've looked at already and don't process edges twice.
crossingPoints = testPointPlane.findCrossings(planetModel, edge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
// Every edge should be looked at only once.
if (seenEdges != null && seenEdges.contains(edge)) {
return true;
} }
if (crossingPoints != null) { if (seenEdges == null) {
// We need to handle the endpoint case, which is quite tricky. seenEdges = new HashSet<>();
for (final GeoPoint crossingPoint : crossingPoints) { }
countCrossingPoint(crossingPoint, edge); seenEdges.add(edge);
//System.out.println("Considering edge "+(edge.startPoint)+" -> "+(edge.endPoint));
// We've never seen this edge before. Evaluate it in the context of inner and outer planes.
computeInsideOutside();
/*
System.out.println("\nThe following edges should intersect the travel/testpoint planes:");
Edge thisEdge = edge;
while (true) {
final GeoPoint[] travelCrossings = travelPlane.findIntersections(planetModel, thisEdge.plane, checkPointCutoffPlane, checkPointOtherCutoffPlane, thisEdge.startPlane, thisEdge.endPlane);
if (travelCrossings == null || travelCrossings.length > 0) {
System.out.println("Travel plane: "+thisEdge.startPoint+" -> "+thisEdge.endPoint);
}
final GeoPoint[] testPointCrossings = testPointPlane.findIntersections(planetModel, thisEdge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, thisEdge.startPlane, thisEdge.endPlane);
if (testPointCrossings == null || testPointCrossings.length > 0) {
System.out.println("Test point plane: "+thisEdge.startPoint+" -> "+thisEdge.endPoint);
}
thisEdge = thisEdge.next;
if (thisEdge == edge) {
break;
} }
//System.err.println(" All crossing points processed");
} else {
//System.err.println(" No crossing points!");
} }
System.out.println("");
*/
// Some edges are going to be given to us even when there's no real intersection, so do that as a sanity check, first.
final GeoPoint[] travelCrossings = travelPlane.findIntersections(planetModel, edge.plane, checkPointCutoffPlane, checkPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
if (travelCrossings != null && travelCrossings.length == 0) {
final GeoPoint[] testPointCrossings = testPointPlane.findIntersections(planetModel, edge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, edge.startPlane, edge.endPlane);
if (testPointCrossings != null && testPointCrossings.length == 0) {
return true;
}
}
// Determine crossings of this edge against all inside/outside planes. There's no further need to look at the actual travel plane itself.
final GeoPoint[] travelInnerCrossings = travelInsidePlane.findCrossings(planetModel, edge.plane, checkPointCutoffPlane, insideTravelCutoffPlane, edge.startPlane, edge.endPlane);
final GeoPoint[] travelOuterCrossings = travelOutsidePlane.findCrossings(planetModel, edge.plane, checkPointCutoffPlane, outsideTravelCutoffPlane, edge.startPlane, edge.endPlane);
final GeoPoint[] testPointInnerCrossings = testPointInsidePlane.findCrossings(planetModel, edge.plane, testPointCutoffPlane, insideTestPointCutoffPlane, edge.startPlane, edge.endPlane);
final GeoPoint[] testPointOuterCrossings = testPointOutsidePlane.findCrossings(planetModel, edge.plane, testPointCutoffPlane, outsideTestPointCutoffPlane, edge.startPlane, edge.endPlane);
// If the edge goes through the inner-inner intersection point, or the outer-outer intersection point, we need to be sure we count that only once.
// It may appear in both lists. Use a hash for this right now.
final Set<GeoPoint> countingHash = new HashSet<>(2);
if (travelInnerCrossings != null) {
for (final GeoPoint crossing : travelInnerCrossings) {
//System.out.println(" Travel inner point "+crossing);
countingHash.add(crossing);
}
}
if (testPointInnerCrossings != null) {
for (final GeoPoint crossing : testPointInnerCrossings) {
//System.out.println(" Test point inner point "+crossing);
countingHash.add(crossing);
}
}
//System.out.println(" Edge added "+countingHash.size()+" to innerCrossingCount");
innerCrossingCount += countingHash.size();
countingHash.clear();
if (travelOuterCrossings != null) {
for (final GeoPoint crossing : travelOuterCrossings) {
//System.out.println(" Travel outer point "+crossing);
countingHash.add(crossing);
}
}
if (testPointOuterCrossings != null) {
for (final GeoPoint crossing : testPointOuterCrossings) {
//System.out.println(" Test point outer point "+crossing);
countingHash.add(crossing);
}
}
//System.out.println(" Edge added "+countingHash.size()+" to outerCrossingCount");
outerCrossingCount += countingHash.size();
return true; return true;
} }
private void countCrossingPoint(final GeoPoint crossingPoint, final Edge edge) {
//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;
// (2) The crossing point and the intersection point are the same, and they *are* the endpoint of an edge.
// The other logical difference is that crossings of all kinds have to be considered so that:
// (a) both inside edges are considered together at all times;
// (b) both outside edges are considered together at all times;
// (c) inside edge crossings that are between the other leg's inside and outside edge are ignored.
// Intersection point crossings are either simple, or a crossing on an endpoint.
// 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.");
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");
return;
}
}
}
}
// Plane crossing, either first leg or second leg
if (crossingPoint.isNumericallyIdentical(edge.startPoint)) {
//System.err.println(" Crossing point = edge.startPoint");
// We have to figure out if this crossing should be counted.
computeInsideOutside();
// Does the crossing for this edge go up, or down? Or can't we tell?
final GeoPoint[] insideTestPointPlaneIntersections = testPointInsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTestPointCutoffPlane);
final GeoPoint[] insideTravelPlaneIntersections = travelInsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTravelCutoffPlane);
final GeoPoint[] outsideTestPointPlaneIntersections = testPointOutsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] outsideTravelPlaneIntersections = travelOutsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
if ((insideTestPointPlaneIntersections == null || insideTestPointPlaneIntersections.length == 0) &&
(insideTravelPlaneIntersections == null || insideTravelPlaneIntersections.length == 0) &&
(outsideTestPointPlaneIntersections == null || outsideTestPointPlaneIntersections.length == 0) &&
(outsideTravelPlaneIntersections == null || outsideTravelPlaneIntersections.length == 0)) {
//System.err.println(" No inside or outside crossings found");
return;
}
final boolean edgeCrossesInside = insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessInsideTestPointIntersections;
GeoPoint[] assessInsideTravelIntersections;
GeoPoint[] assessOutsideTestPointIntersections;
GeoPoint[] assessOutsideTravelIntersections;
while (true) {
assessEdge = assessEdge.previous;
assessInsideTestPointIntersections = testPointInsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane, insideTestPointCutoffPlane);
assessInsideTravelIntersections = travelInsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane, insideTravelCutoffPlane);
assessOutsideTestPointIntersections = testPointOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessOutsideTravelIntersections = travelOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
// If the assess edge is numerically identical to the edge we're trying to find the intersections with, there's not really a crossing, so count it as zero.
if ((assessInsideTestPointIntersections == null || assessInsideTestPointIntersections.length == 0) &&
(assessInsideTravelIntersections == null || assessInsideTravelIntersections.length == 0) &&
(assessOutsideTestPointIntersections == null || assessOutsideTestPointIntersections.length == 0) &&
(assessOutsideTravelIntersections == null || assessOutsideTravelIntersections.length == 0)) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// To handle the latter situation, we need to know if the other edge will be looked at also, and then we can make
// a decision whether to count or not based on that.
// Compute the crossing points of this other edge.
final GeoPoint[] otherCrossingPoints;
if (isSecondLeg) {
otherCrossingPoints = travelPlane.findCrossings(planetModel, assessEdge.plane, checkPointCutoffPlane, checkPointOtherCutoffPlane, assessEdge.startPlane, assessEdge.endPlane);
} else {
otherCrossingPoints = testPointPlane.findCrossings(planetModel, assessEdge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, assessEdge.startPlane, assessEdge.endPlane);
}
if (otherCrossingPoints == null) {
// The assessEdge plane is the same as the travel plane. We consider this the same as "no crossing".
return;
}
// Look for a matching endpoint. If the other endpoint doesn't show up, it is either out of bounds (in which case the
// transition won't be counted for that edge), or it is not a crossing for that edge (so, same conclusion).
for (final GeoPoint otherCrossingPoint : otherCrossingPoints) {
if (otherCrossingPoint.isNumericallyIdentical(assessEdge.endPoint)) {
// 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;
}
}
// Both edges will not count the same point, so we can proceed. We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeInside = (assessInsideTestPointIntersections != null && assessInsideTestPointIntersections.length > 0) ||
(assessInsideTravelIntersections != null && 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");
// Figure out if the crossing should be counted.
computeInsideOutside();
// If the assess edge is numerically identical to the edge we're trying to find the intersections with, there's not really a crossing, so count it as zero.
// Does the crossing for this edge go up, or down? Or can't we tell?
final GeoPoint[] insideTestPointPlaneIntersections = testPointInsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTestPointCutoffPlane);
final GeoPoint[] insideTravelPlaneIntersections = travelInsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTravelCutoffPlane);
final GeoPoint[] outsideTestPointPlaneIntersections = testPointOutsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
final GeoPoint[] outsideTravelPlaneIntersections = travelOutsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
// An edge can cross both outside and inside, because of the corner. But it can be considered to cross the inside ONLY if it crosses either of the inside edges.
if ((insideTestPointPlaneIntersections == null || insideTestPointPlaneIntersections.length == 0) &&
(insideTravelPlaneIntersections == null || insideTravelPlaneIntersections.length == 0) &&
(outsideTestPointPlaneIntersections == null || outsideTestPointPlaneIntersections.length == 0) &&
(outsideTravelPlaneIntersections == null || outsideTravelPlaneIntersections.length == 0)) {
//System.err.println(" No inside or outside crossings found");
return;
}
final boolean edgeCrossesInside = (insideTestPointPlaneIntersections !=null && insideTestPointPlaneIntersections.length > 0) ||
(insideTravelPlaneIntersections != null && insideTravelPlaneIntersections.length > 0);
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
GeoPoint[] assessInsideTestPointIntersections;
GeoPoint[] assessInsideTravelIntersections;
GeoPoint[] assessOutsideTestPointIntersections;
GeoPoint[] assessOutsideTravelIntersections;
while (true) {
assessEdge = assessEdge.next;
assessInsideTestPointIntersections = testPointInsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane, insideTestPointCutoffPlane);
assessInsideTravelIntersections = travelInsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane, insideTravelCutoffPlane);
assessOutsideTestPointIntersections = testPointOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessOutsideTravelIntersections = travelOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
if ((assessInsideTestPointIntersections == null || assessInsideTestPointIntersections.length == 0) &&
(assessInsideTravelIntersections == null || assessInsideTravelIntersections.length == 0) &&
(assessOutsideTestPointIntersections == null || assessOutsideTestPointIntersections.length == 0) &&
(assessOutsideTravelIntersections == null || assessOutsideTravelIntersections.length == 0)) {
continue;
}
break;
}
// Basically, we now want to assess whether both edges that come together at this endpoint leave the plane in opposite
// directions. If they do, then we should count it as a crossing; if not, we should not. We also have to remember that
// each edge we look at can also be looked at again if it, too, seems to cross the plane.
// By definition, we're the earlier plane in this case, so any crossing we detect we must count, by convention. It is unnecessary
// to consider what the other edge does, because when we get to it, it will look back and figure out what we did for this one.
// We need to determine the direction of both edges at the
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
final boolean assessEdgeInside = (assessInsideTestPointIntersections !=null && assessInsideTestPointIntersections.length > 0) ||
(assessInsideTravelIntersections != null && 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");
// Not a special case, so we can safely count a crossing.
crossingCount++;
}
}
} }
private static double computeSquaredDistance(final GeoPoint checkPoint, final GeoPoint intersectionPoint) {
final double distanceX = checkPoint.x - intersectionPoint.x;
final double distanceY = checkPoint.y - intersectionPoint.y;
final double distanceZ = checkPoint.z - intersectionPoint.z;
return distanceX * distanceX + distanceY * distanceY + distanceZ * distanceZ;
}
@Override @Override
public boolean equals(Object o) { public boolean equals(Object o) {
if (!(o instanceof GeoComplexPolygon)) if (!(o instanceof GeoComplexPolygon))

View File

@ -81,8 +81,6 @@ import org.apache.lucene.util.NumericUtils;
import org.apache.lucene.util.StringHelper; import org.apache.lucene.util.StringHelper;
import org.apache.lucene.util.TestUtil; import org.apache.lucene.util.TestUtil;
import org.junit.Ignore;
import com.carrotsearch.randomizedtesting.generators.RandomNumbers; import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
public class TestGeo3DPoint extends LuceneTestCase { public class TestGeo3DPoint extends LuceneTestCase {
@ -190,8 +188,7 @@ public class TestGeo3DPoint extends LuceneTestCase {
} }
/** Tests consistency of GeoArea.getRelationship vs GeoShape.isWithin */ /** Tests consistency of GeoArea.getRelationship vs GeoShape.isWithin */
//@AwaitsFix("https://issues.apache.org/jira/browse/LUCENE-8227") @AwaitsFix(bugUrl="https://issues.apache.org/jira/browse/LUCENE-8227")
@Ignore
public void testGeo3DRelations() throws Exception { public void testGeo3DRelations() throws Exception {
int numDocs = atLeast(1000); int numDocs = atLeast(1000);
@ -471,22 +468,16 @@ public class TestGeo3DPoint extends LuceneTestCase {
} }
} }
//@AwaitsFix("https://issues.apache.org/jira/browse/LUCENE-8227")
@Ignore
public void testRandomTiny() throws Exception { public void testRandomTiny() throws Exception {
// Make sure single-leaf-node case is OK: // Make sure single-leaf-node case is OK:
doTestRandom(10); doTestRandom(10);
} }
//@AwaitsFix("https://issues.apache.org/jira/browse/LUCENE-8227")
@Ignore
public void testRandomMedium() throws Exception { public void testRandomMedium() throws Exception {
doTestRandom(10000); doTestRandom(10000);
} }
@Nightly @Nightly
//@AwaitsFix("https://issues.apache.org/jira/browse/LUCENE-8227")
@Ignore
public void testRandomBig() throws Exception { public void testRandomBig() throws Exception {
doTestRandom(50000); doTestRandom(50000);
} }

View File

@ -253,6 +253,7 @@ public class GeoPolygonTest {
shapes.add(pd); shapes.add(pd);
c = GeoPolygonFactory.makeLargeGeoPolygon(PlanetModel.SPHERE, shapes); c = GeoPolygonFactory.makeLargeGeoPolygon(PlanetModel.SPHERE, shapes);
//System.out.println("Large polygon = "+c);
// Sample some points within // Sample some points within
gp = new GeoPoint(PlanetModel.SPHERE, 0.0, -0.45); gp = new GeoPoint(PlanetModel.SPHERE, 0.0, -0.45);
@ -1217,7 +1218,6 @@ shape:
[junit4] 1> quantized=[X=-0.9951793580415914, Y=-0.10888987641797832, Z=-2.3309121299774915E-10] [junit4] 1> quantized=[X=-0.9951793580415914, Y=-0.10888987641797832, Z=-2.3309121299774915E-10]
*/ */
@Test @Test
@Ignore
public void testLUCENE8227() throws Exception { public void testLUCENE8227() throws Exception {
List<GeoPoint> points = new ArrayList<>(); List<GeoPoint> points = new ArrayList<>();
points.add(new GeoPoint(PlanetModel.WGS84, -0.63542308910253, 0.9853722928232957)); points.add(new GeoPoint(PlanetModel.WGS84, -0.63542308910253, 0.9853722928232957));
@ -1227,9 +1227,11 @@ shape:
points.add(new GeoPoint(PlanetModel.WGS84, -1.2205765069413237, 3.141592653589793)); points.add(new GeoPoint(PlanetModel.WGS84, -1.2205765069413237, 3.141592653589793));
GeoPolygonFactory.PolygonDescription pd = new GeoPolygonFactory.PolygonDescription(points); GeoPolygonFactory.PolygonDescription pd = new GeoPolygonFactory.PolygonDescription(points);
/*
for (int i = 0; i < points.size(); i++) { for (int i = 0; i < points.size(); i++) {
System.out.println("Point "+i+": "+points.get(i)); System.out.println("Point "+i+": "+points.get(i));
} }
*/
final GeoPoint unquantized = new GeoPoint(PlanetModel.WGS84, -3.1780051348770987E-74, -3.032608859187692); final GeoPoint unquantized = new GeoPoint(PlanetModel.WGS84, -3.1780051348770987E-74, -3.032608859187692);
final GeoPoint quantized = new GeoPoint(-0.9951793580415914, -0.10888987641797832, -2.3309121299774915E-10); final GeoPoint quantized = new GeoPoint(-0.9951793580415914, -0.10888987641797832, -2.3309121299774915E-10);
@ -1237,31 +1239,22 @@ shape:
final GeoPoint negativeX = new GeoPoint(PlanetModel.WGS84, 0.0, Math.PI); final GeoPoint negativeX = new GeoPoint(PlanetModel.WGS84, 0.0, Math.PI);
final GeoPoint negativeY = new GeoPoint(PlanetModel.WGS84, 0.0, -Math.PI * 0.5); final GeoPoint negativeY = new GeoPoint(PlanetModel.WGS84, 0.0, -Math.PI * 0.5);
// Construct a standard polygon first to see what that does // Construct a standard polygon first to see what that does. This winds up being a large polygon under the covers.
GeoPolygon standard = GeoPolygonFactory.makeGeoPolygon(PlanetModel.WGS84, pd); GeoPolygon standard = GeoPolygonFactory.makeGeoPolygon(PlanetModel.WGS84, pd);
System.out.println("Standard polygon: "+standard);
// This shows y < 0 hemisphere is all in-set // This shows y < 0 hemisphere is all in-set
//assertTrue(standard.isWithin(negativeY)); //assertTrue(standard.isWithin(negativeY));
// This should be in-set too, but isn't!! // This should be in-set too, but isn't!!
assertTrue(standard.isWithin(negativeX)); assertTrue(standard.isWithin(negativeX));
/*
final XYZBounds standardBounds = new XYZBounds(); final XYZBounds standardBounds = new XYZBounds();
standard.getBounds(standardBounds); standard.getBounds(standardBounds);
final XYZSolid standardSolid = XYZSolidFactory.makeXYZSolid(PlanetModel.WGS84, standardBounds); final XYZSolid standardSolid = XYZSolidFactory.makeXYZSolid(PlanetModel.WGS84, standardBounds);
System.out.println("Standard bounds: "+standardBounds); // If within shape, should be within bounds
assertTrue(standard.isWithin(quantized)?standardSolid.isWithin(quantized):true);
assertTrue(standard.isWithin(unquantized)?standardSolid.isWithin(unquantized):true);
assertFalse(standardSolid.isWithin(quantized));
assertFalse(standardSolid.isWithin(unquantized));
*/
// Now, both points should also not be in the poly
assertFalse(standard.isWithin(unquantized));
assertFalse(standard.isWithin(quantized));
} }
} }