/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.lucene.spatial3d.geom;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

3D rectangle, bounded on six sides by X,Y,Z limits
@lucene.internal
/** * 3D rectangle, bounded on six sides by X,Y,Z limits * * @lucene.internal */
class StandardXYZSolid extends BaseXYZSolid {
Min-X
/** Min-X */
protected final double minX;
Max-X
/** Max-X */
protected final double maxX;
Min-Y
/** Min-Y */
protected final double minY;
Max-Y
/** Max-Y */
protected final double maxY;
Min-Z
/** Min-Z */
protected final double minZ;
Max-Z
/** Max-Z */
protected final double maxZ;
Whole world?
/** Whole world? */
protected final boolean isWholeWorld;
Min-X plane
/** Min-X plane */
protected final SidedPlane minXPlane;
Max-X plane
/** Max-X plane */
protected final SidedPlane maxXPlane;
Min-Y plane
/** Min-Y plane */
protected final SidedPlane minYPlane;
Max-Y plane
/** Max-Y plane */
protected final SidedPlane maxYPlane;
Min-Z plane
/** Min-Z plane */
protected final SidedPlane minZPlane;
Max-Z plane
/** Max-Z plane */
protected final SidedPlane maxZPlane;
true if minXPlane intersects globe
/** true if minXPlane intersects globe */
protected final boolean minXPlaneIntersects;
true if maxXPlane intersects globe
/** true if maxXPlane intersects globe */
protected final boolean maxXPlaneIntersects;
true if minYPlane intersects globe
/** true if minYPlane intersects globe */
protected final boolean minYPlaneIntersects;
true if maxYPlane intersects globe
/** true if maxYPlane intersects globe */
protected final boolean maxYPlaneIntersects;
true if minZPlane intersects globe
/** true if minZPlane intersects globe */
protected final boolean minZPlaneIntersects;
true if maxZPlane intersects globe
/** true if maxZPlane intersects globe */
protected final boolean maxZPlaneIntersects;
These are the edge points of the shape, which are defined to be at least one point on each surface area boundary. In the case of a solid, this includes points which represent the intersection of XYZ bounding planes and the planet, as well as points representing the intersection of single bounding planes with the planet itself.
/** These are the edge points of the shape, which are defined to be at least one point on * each surface area boundary. In the case of a solid, this includes points which represent * the intersection of XYZ bounding planes and the planet, as well as points representing * the intersection of single bounding planes with the planet itself. */
protected final GeoPoint[] edgePoints;
Notable points for minXPlane
/** Notable points for minXPlane */
protected final GeoPoint[] notableMinXPoints;
Notable points for maxXPlane
/** Notable points for maxXPlane */
protected final GeoPoint[] notableMaxXPoints;
Notable points for minYPlane
/** Notable points for minYPlane */
protected final GeoPoint[] notableMinYPoints;
Notable points for maxYPlane
/** Notable points for maxYPlane */
protected final GeoPoint[] notableMaxYPoints;
Notable points for minZPlane
/** Notable points for minZPlane */
protected final GeoPoint[] notableMinZPoints;
Notable points for maxZPlane
/** Notable points for maxZPlane */
protected final GeoPoint[] notableMaxZPoints;
Sole constructor
Params:
  • planetModel – is the planet model.
  • minX – is the minimum X value.
  • maxX – is the maximum X value.
  • minY – is the minimum Y value.
  • maxY – is the maximum Y value.
  • minZ – is the minimum Z value.
  • maxZ – is the maximum Z value.
/** * Sole constructor * *@param planetModel is the planet model. *@param minX is the minimum X value. *@param maxX is the maximum X value. *@param minY is the minimum Y value. *@param maxY is the maximum Y value. *@param minZ is the minimum Z value. *@param maxZ is the maximum Z value. */
public StandardXYZSolid(final PlanetModel planetModel, final double minX, final double maxX, final double minY, final double maxY, final double minZ, final double maxZ) { super(planetModel); // Argument checking if (maxX - minX < Vector.MINIMUM_RESOLUTION) throw new IllegalArgumentException("X values in wrong order or identical"); if (maxY - minY < Vector.MINIMUM_RESOLUTION) throw new IllegalArgumentException("Y values in wrong order or identical"); if (maxZ - minZ < Vector.MINIMUM_RESOLUTION) throw new IllegalArgumentException("Z values in wrong order or identical"); this.minX = minX; this.maxX = maxX; this.minY = minY; this.maxY = maxY; this.minZ = minZ; this.maxZ = maxZ; final double worldMinX = planetModel.getMinimumXValue(); final double worldMaxX = planetModel.getMaximumXValue(); final double worldMinY = planetModel.getMinimumYValue(); final double worldMaxY = planetModel.getMaximumYValue(); final double worldMinZ = planetModel.getMinimumZValue(); final double worldMaxZ = planetModel.getMaximumZValue(); // We must distinguish between the case where the solid represents the entire world, // and when the solid has no overlap with any part of the surface. In both cases, // there will be no edgepoints. isWholeWorld = (minX - worldMinX < -Vector.MINIMUM_RESOLUTION) && (maxX - worldMaxX > Vector.MINIMUM_RESOLUTION) && (minY - worldMinY < -Vector.MINIMUM_RESOLUTION) && (maxY - worldMaxY > Vector.MINIMUM_RESOLUTION) && (minZ - worldMinZ < -Vector.MINIMUM_RESOLUTION) && (maxZ - worldMaxZ > Vector.MINIMUM_RESOLUTION); if (isWholeWorld) { minXPlane = null; maxXPlane = null; minYPlane = null; maxYPlane = null; minZPlane = null; maxZPlane = null; minXPlaneIntersects = false; maxXPlaneIntersects = false; minYPlaneIntersects = false; maxYPlaneIntersects = false; minZPlaneIntersects = false; maxZPlaneIntersects = false; notableMinXPoints = null; notableMaxXPoints = null; notableMinYPoints = null; notableMaxYPoints = null; notableMinZPoints = null; notableMaxZPoints = null; edgePoints = null; } else { // Construct the planes minXPlane = new SidedPlane(maxX,0.0,0.0,xUnitVector,-minX); maxXPlane = new SidedPlane(minX,0.0,0.0,xUnitVector,-maxX); minYPlane = new SidedPlane(0.0,maxY,0.0,yUnitVector,-minY); maxYPlane = new SidedPlane(0.0,minY,0.0,yUnitVector,-maxY); minZPlane = new SidedPlane(0.0,0.0,maxZ,zUnitVector,-minZ); maxZPlane = new SidedPlane(0.0,0.0,minZ,zUnitVector,-maxZ); // We need at least one point on the planet surface for each manifestation of the shape. // There can be up to 2 (on opposite sides of the world). But we have to go through // 12 combinations of adjacent planes in order to find out if any have 2 intersection solution. // Typically, this requires 12 square root operations. final GeoPoint[] minXminY = minXPlane.findIntersections(planetModel,minYPlane,maxXPlane,maxYPlane,minZPlane,maxZPlane); final GeoPoint[] minXmaxY = minXPlane.findIntersections(planetModel,maxYPlane,maxXPlane,minYPlane,minZPlane,maxZPlane); final GeoPoint[] minXminZ = minXPlane.findIntersections(planetModel,minZPlane,maxXPlane,maxZPlane,minYPlane,maxYPlane); final GeoPoint[] minXmaxZ = minXPlane.findIntersections(planetModel,maxZPlane,maxXPlane,minZPlane,minYPlane,maxYPlane); final GeoPoint[] maxXminY = maxXPlane.findIntersections(planetModel,minYPlane,minXPlane,maxYPlane,minZPlane,maxZPlane); final GeoPoint[] maxXmaxY = maxXPlane.findIntersections(planetModel,maxYPlane,minXPlane,minYPlane,minZPlane,maxZPlane); final GeoPoint[] maxXminZ = maxXPlane.findIntersections(planetModel,minZPlane,minXPlane,maxZPlane,minYPlane,maxYPlane); final GeoPoint[] maxXmaxZ = maxXPlane.findIntersections(planetModel,maxZPlane,minXPlane,minZPlane,minYPlane,maxYPlane); final GeoPoint[] minYminZ = minYPlane.findIntersections(planetModel,minZPlane,maxYPlane,maxZPlane,minXPlane,maxXPlane); final GeoPoint[] minYmaxZ = minYPlane.findIntersections(planetModel,maxZPlane,maxYPlane,minZPlane,minXPlane,maxXPlane); final GeoPoint[] maxYminZ = maxYPlane.findIntersections(planetModel,minZPlane,minYPlane,maxZPlane,minXPlane,maxXPlane); final GeoPoint[] maxYmaxZ = maxYPlane.findIntersections(planetModel,maxZPlane,minYPlane,minZPlane,minXPlane,maxXPlane); notableMinXPoints = glueTogether(minXminY, minXmaxY, minXminZ, minXmaxZ); notableMaxXPoints = glueTogether(maxXminY, maxXmaxY, maxXminZ, maxXmaxZ); notableMinYPoints = glueTogether(minXminY, maxXminY, minYminZ, minYmaxZ); notableMaxYPoints = glueTogether(minXmaxY, maxXmaxY, maxYminZ, maxYmaxZ); notableMinZPoints = glueTogether(minXminZ, maxXminZ, minYminZ, maxYminZ); notableMaxZPoints = glueTogether(minXmaxZ, maxXmaxZ, minYmaxZ, maxYmaxZ); //System.err.println( // " notableMinXPoints="+Arrays.asList(notableMinXPoints)+" notableMaxXPoints="+Arrays.asList(notableMaxXPoints)+ // " notableMinYPoints="+Arrays.asList(notableMinYPoints)+" notableMaxYPoints="+Arrays.asList(notableMaxYPoints)+ // " notableMinZPoints="+Arrays.asList(notableMinZPoints)+" notableMaxZPoints="+Arrays.asList(notableMaxZPoints)); // Now, compute the edge points. // This is the trickiest part of setting up an XYZSolid. We've computed intersections already, so // we'll start there. // There can be a number of shapes, each of which needs an edgepoint. Each side by itself might contribute // an edgepoint, for instance, if the plane describing that side intercepts the planet in such a way that the ellipse // of interception does not meet any other planes. Plane intersections can each contribute 0, 1, or 2 edgepoints. // // All of this makes for a lot of potential edgepoints, but I believe these can be pruned back with careful analysis. // I haven't yet done that analysis, however, so I will treat them all as individual edgepoints. // The cases we are looking for are when the four corner points for any given // plane are all outside of the world, AND that plane intersects the world. // There are eight corner points all told; we must evaluate these WRT the planet surface. final boolean minXminYminZ = planetModel.pointOutside(minX, minY, minZ); final boolean minXminYmaxZ = planetModel.pointOutside(minX, minY, maxZ); final boolean minXmaxYminZ = planetModel.pointOutside(minX, maxY, minZ); final boolean minXmaxYmaxZ = planetModel.pointOutside(minX, maxY, maxZ); final boolean maxXminYminZ = planetModel.pointOutside(maxX, minY, minZ); final boolean maxXminYmaxZ = planetModel.pointOutside(maxX, minY, maxZ); final boolean maxXmaxYminZ = planetModel.pointOutside(maxX, maxY, minZ); final boolean maxXmaxYmaxZ = planetModel.pointOutside(maxX, maxY, maxZ); //System.err.println("Outside world: minXminYminZ="+minXminYminZ+" minXminYmaxZ="+minXminYmaxZ+" minXmaxYminZ="+minXmaxYminZ+ // " minXmaxYmaxZ="+minXmaxYmaxZ+" maxXminYminZ="+maxXminYminZ+" maxXminYmaxZ="+maxXminYmaxZ+" maxXmaxYminZ="+maxXmaxYminZ+ // " maxXmaxYmaxZ="+maxXmaxYmaxZ); // Look at single-plane/world intersections. // We detect these by looking at the world model and noting its x, y, and z bounds. final GeoPoint[] minXEdges; if (minX - worldMinX >= -Vector.MINIMUM_RESOLUTION && minX - worldMaxX <= Vector.MINIMUM_RESOLUTION && minY < 0.0 && maxY > 0.0 && minZ < 0.0 && maxZ > 0.0 && minXminYminZ && minXminYmaxZ && minXmaxYminZ && minXmaxYmaxZ) { // Find any point on the minX plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (1,0,0) // Then use it to compute a sample point. final GeoPoint intPoint = minXPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane); if (intPoint != null) { minXEdges = new GeoPoint[]{intPoint}; } else { // No intersection found? minXEdges = EMPTY_POINTS; } } else { minXEdges = EMPTY_POINTS; } final GeoPoint[] maxXEdges; if (maxX - worldMinX >= -Vector.MINIMUM_RESOLUTION && maxX - worldMaxX <= Vector.MINIMUM_RESOLUTION && minY < 0.0 && maxY > 0.0 && minZ < 0.0 && maxZ > 0.0 && maxXminYminZ && maxXminYmaxZ && maxXmaxYminZ && maxXmaxYmaxZ) { // Find any point on the maxX plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (1,0,0) // Then use it to compute a sample point. final GeoPoint intPoint = maxXPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane); if (intPoint != null) { maxXEdges = new GeoPoint[]{intPoint}; } else { maxXEdges = EMPTY_POINTS; } } else { maxXEdges = EMPTY_POINTS; } final GeoPoint[] minYEdges; if (minY - worldMinY >= -Vector.MINIMUM_RESOLUTION && minY - worldMaxY <= Vector.MINIMUM_RESOLUTION && minX < 0.0 && maxX > 0.0 && minZ < 0.0 && maxZ > 0.0 && minXminYminZ && minXminYmaxZ && maxXminYminZ && maxXminYmaxZ) { // Find any point on the minY plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (0,1,0) // Then use it to compute a sample point. final GeoPoint intPoint = minYPlane.getSampleIntersectionPoint(planetModel, yVerticalPlane); if (intPoint != null) { minYEdges = new GeoPoint[]{intPoint}; } else { minYEdges = EMPTY_POINTS; } } else { minYEdges = EMPTY_POINTS; } final GeoPoint[] maxYEdges; if (maxY - worldMinY >= -Vector.MINIMUM_RESOLUTION && maxY - worldMaxY <= Vector.MINIMUM_RESOLUTION && minX < 0.0 && maxX > 0.0 && minZ < 0.0 && maxZ > 0.0 && minXmaxYminZ && minXmaxYmaxZ && maxXmaxYminZ && maxXmaxYmaxZ) { // Find any point on the maxY plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (0,1,0) // Then use it to compute a sample point. final GeoPoint intPoint = maxYPlane.getSampleIntersectionPoint(planetModel, yVerticalPlane); if (intPoint != null) { maxYEdges = new GeoPoint[]{intPoint}; } else { maxYEdges = EMPTY_POINTS; } } else { maxYEdges = EMPTY_POINTS; } final GeoPoint[] minZEdges; if (minZ - worldMinZ >= -Vector.MINIMUM_RESOLUTION && minZ - worldMaxZ <= Vector.MINIMUM_RESOLUTION && minX < 0.0 && maxX > 0.0 && minY < 0.0 && maxY > 0.0 && minXminYminZ && minXmaxYminZ && maxXminYminZ && maxXmaxYminZ) { // Find any point on the minZ plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (1,0,0) // Then use it to compute a sample point. final GeoPoint intPoint = minZPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane); if (intPoint != null) { minZEdges = new GeoPoint[]{intPoint}; } else { minZEdges = EMPTY_POINTS; } } else { minZEdges = EMPTY_POINTS; } final GeoPoint[] maxZEdges; if (maxZ - worldMinZ >= -Vector.MINIMUM_RESOLUTION && maxZ - worldMaxZ <= Vector.MINIMUM_RESOLUTION && minX < 0.0 && maxX > 0.0 && minY < 0.0 && maxY > 0.0 && minXminYmaxZ && minXmaxYmaxZ && maxXminYmaxZ && maxXmaxYmaxZ) { // Find any point on the maxZ plane that intersects the world // First construct a perpendicular plane that will allow us to find a sample point. // This plane is vertical and goes through the points (0,0,0) and (1,0,0) (that is, its orientation doesn't matter) // Then use it to compute a sample point. final GeoPoint intPoint = maxZPlane.getSampleIntersectionPoint(planetModel, xVerticalPlane); if (intPoint != null) { maxZEdges = new GeoPoint[]{intPoint}; } else { maxZEdges = EMPTY_POINTS; } } else { maxZEdges = EMPTY_POINTS; } //System.err.println( // " minXEdges="+Arrays.asList(minXEdges)+" maxXEdges="+Arrays.asList(maxXEdges)+ // " minYEdges="+Arrays.asList(minYEdges)+" maxYEdges="+Arrays.asList(maxYEdges)+ // " minZEdges="+Arrays.asList(minZEdges)+" maxZEdges="+Arrays.asList(maxZEdges)); minXPlaneIntersects = notableMinXPoints.length + minXEdges.length > 0; maxXPlaneIntersects = notableMaxXPoints.length + maxXEdges.length > 0; minYPlaneIntersects = notableMinYPoints.length + minYEdges.length > 0; maxYPlaneIntersects = notableMaxYPoints.length + maxYEdges.length > 0; minZPlaneIntersects = notableMinZPoints.length + minZEdges.length > 0; maxZPlaneIntersects = notableMaxZPoints.length + maxZEdges.length > 0; // Glue everything together. This is not a minimal set of edgepoints, as of now, but it does completely describe all shapes on the // planet. this.edgePoints = glueTogether(minXminY, minXmaxY, minXminZ, minXmaxZ, maxXminY, maxXmaxY, maxXminZ, maxXmaxZ, minYminZ, minYmaxZ, maxYminZ, maxYmaxZ, minXEdges, maxXEdges, minYEdges, maxYEdges, minZEdges, maxZEdges); } }
Constructor for deserialization.
Params:
  • planetModel – is the planet model.
  • inputStream – is the input stream.
/** * Constructor for deserialization. * @param planetModel is the planet model. * @param inputStream is the input stream. */
public StandardXYZSolid(final PlanetModel planetModel, final InputStream inputStream) throws IOException { this(planetModel, SerializableObject.readDouble(inputStream), SerializableObject.readDouble(inputStream), SerializableObject.readDouble(inputStream), SerializableObject.readDouble(inputStream), SerializableObject.readDouble(inputStream), SerializableObject.readDouble(inputStream)); } @Override public void write(final OutputStream outputStream) throws IOException { SerializableObject.writeDouble(outputStream, minX); SerializableObject.writeDouble(outputStream, maxX); SerializableObject.writeDouble(outputStream, minY); SerializableObject.writeDouble(outputStream, maxY); SerializableObject.writeDouble(outputStream, minZ); SerializableObject.writeDouble(outputStream, maxZ); } @Override protected GeoPoint[] getEdgePoints() { return edgePoints; } @Override public boolean isWithin(final double x, final double y, final double z) { if (isWholeWorld) { return true; } return minXPlane.isWithin(x, y, z) && maxXPlane.isWithin(x, y, z) && minYPlane.isWithin(x, y, z) && maxYPlane.isWithin(x, y, z) && minZPlane.isWithin(x, y, z) && maxZPlane.isWithin(x, y, z); } @Override public int getRelationship(final GeoShape path) { if (isWholeWorld) { if (path.getEdgePoints().length > 0) return WITHIN; return OVERLAPS; } /* for (GeoPoint p : getEdgePoints()) { System.err.println(" Edge point "+p+" path.isWithin()? "+path.isWithin(p)); } for (GeoPoint p : path.getEdgePoints()) { System.err.println(" path edge point "+p+" isWithin()? "+isWithin(p)+" minx="+minXPlane.evaluate(p)+" maxx="+maxXPlane.evaluate(p)+" miny="+minYPlane.evaluate(p)+" maxy="+maxYPlane.evaluate(p)+" minz="+minZPlane.evaluate(p)+" maxz="+maxZPlane.evaluate(p)); } */ //System.err.println(this+" getrelationship with "+path); final int insideRectangle = isShapeInsideArea(path); if (insideRectangle == SOME_INSIDE) { //System.err.println(" some shape points inside area"); return OVERLAPS; } // Figure out if the entire XYZArea is contained by the shape. final int insideShape = isAreaInsideShape(path); if (insideShape == SOME_INSIDE) { //System.err.println(" some area points inside shape"); return OVERLAPS; } if (insideRectangle == ALL_INSIDE && insideShape == ALL_INSIDE) { //System.err.println(" inside of each other"); return OVERLAPS; } if ((minXPlaneIntersects && path.intersects(minXPlane, notableMinXPoints, maxXPlane, minYPlane, maxYPlane, minZPlane, maxZPlane)) || (maxXPlaneIntersects && path.intersects(maxXPlane, notableMaxXPoints, minXPlane, minYPlane, maxYPlane, minZPlane, maxZPlane)) || (minYPlaneIntersects && path.intersects(minYPlane, notableMinYPoints, maxYPlane, minXPlane, maxXPlane, minZPlane, maxZPlane)) || (maxYPlaneIntersects && path.intersects(maxYPlane, notableMaxYPoints, minYPlane, minXPlane, maxXPlane, minZPlane, maxZPlane)) || (minZPlaneIntersects && path.intersects(minZPlane, notableMinZPoints, maxZPlane, minXPlane, maxXPlane, minYPlane, maxYPlane)) || (maxZPlaneIntersects && path.intersects(maxZPlane, notableMaxZPoints, minZPlane, minXPlane, maxXPlane, minYPlane, maxYPlane))) { //System.err.println(" edges intersect"); return OVERLAPS; } if (insideRectangle == ALL_INSIDE) { //System.err.println(" all shape points inside area"); return WITHIN; } if (insideShape == ALL_INSIDE) { //System.err.println(" all area points inside shape"); return CONTAINS; } //System.err.println(" disjoint"); return DISJOINT; } @Override public boolean equals(Object o) { if (!(o instanceof StandardXYZSolid)) return false; StandardXYZSolid other = (StandardXYZSolid) o; if (!super.equals(other) || other.isWholeWorld != isWholeWorld) { return false; } if (!isWholeWorld) { return other.minXPlane.equals(minXPlane) && other.maxXPlane.equals(maxXPlane) && other.minYPlane.equals(minYPlane) && other.maxYPlane.equals(maxYPlane) && other.minZPlane.equals(minZPlane) && other.maxZPlane.equals(maxZPlane); } return true; } @Override public int hashCode() { int result = super.hashCode(); result = 31 * result + (isWholeWorld?1:0); if (!isWholeWorld) { result = 31 * result + minXPlane.hashCode(); result = 31 * result + maxXPlane.hashCode(); result = 31 * result + minYPlane.hashCode(); result = 31 * result + maxYPlane.hashCode(); result = 31 * result + minZPlane.hashCode(); result = 31 * result + maxZPlane.hashCode(); } return result; } @Override public String toString() { return "StandardXYZSolid: {planetmodel="+planetModel+", isWholeWorld="+isWholeWorld+", minXplane="+minXPlane+", maxXplane="+maxXPlane+", minYplane="+minYPlane+", maxYplane="+maxYPlane+", minZplane="+minZPlane+", maxZplane="+maxZPlane+"}"; } }