LUCENE-8746: Refactor EdgeTree #878
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,96 @@ | ||
| /* | ||
| * 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.geo; | ||
|
|
||
| import org.apache.lucene.index.PointValues; | ||
|
|
||
| import static org.apache.lucene.geo.GeoUtils.orient; | ||
|
|
||
| /** | ||
| * 2D Geometry object that supports spatial relationships with bounding boxes, | ||
| * triangles and points. | ||
| * | ||
| * @lucene.internal | ||
| **/ | ||
| public interface Component2D { | ||
|
|
||
| /** min X value for the component **/ | ||
| double getMinX(); | ||
|
|
||
| /** max X value for the component **/ | ||
| double getMaxX(); | ||
|
|
||
| /** min Y value for the component **/ | ||
| double getMinY(); | ||
|
|
||
| /** max Y value for the component **/ | ||
| double getMaxY(); | ||
|
|
||
| /** relates this component2D with a point **/ | ||
| boolean contains(double x, double y); | ||
|
|
||
| /** relates this component2D with a bounding box **/ | ||
| PointValues.Relation relate(double minX, double maxX, double minY, double maxY); | ||
|
|
||
| /** relates this component2D with a triangle **/ | ||
| PointValues.Relation relateTriangle(double minX, double maxX, double minY, double maxY, | ||
| double aX, double aY, double bX, double bY, double cX, double cY); | ||
|
|
||
| /** relates this component2D with a triangle **/ | ||
| default PointValues.Relation relateTriangle(double aX, double aY, double bX, double bY, double cX, double cY) { | ||
| double minY = StrictMath.min(StrictMath.min(aY, bY), cY); | ||
| double minX = StrictMath.min(StrictMath.min(aX, bX), cX); | ||
| double maxY = StrictMath.max(StrictMath.max(aY, bY), cY); | ||
| double maxX = StrictMath.max(StrictMath.max(aX, bX), cX); | ||
| return relateTriangle(minX, maxX, minY, maxY, aX, aY, bX, bY, cX, cY); | ||
| } | ||
|
|
||
| /** Compute whether the bounding boxes are disjoint **/ | ||
| static boolean disjoint(double minX1, double maxX1, double minY1, double maxY1, double minX2, double maxX2, double minY2, double maxY2) { | ||
| return (maxY1 < minY2 || minY1 > maxY2 || maxX1 < minX2 || minX1 > maxX2); | ||
| } | ||
|
|
||
| /** Compute whether the first bounding box 1 is within the second bounding box **/ | ||
| static boolean within(double minX1, double maxX1, double minY1, double maxY1, double minX2, double maxX2, double minY2, double maxY2) { | ||
| return (minY2 < minY1 && maxY2 > maxY1&& minX2 < minX1 && maxX2 > maxX1); | ||
iverase marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| } | ||
|
|
||
| /** returns true if rectangle (defined by minX, maxX, minY, maxY) contains the X Y point */ | ||
| static boolean containsPoint(final double x, final double y, final double minX, final double maxX, final double minY, final double maxY) { | ||
| return x >= minX && x <= maxX && y >= minY && y <= maxY; | ||
| } | ||
|
|
||
| /** | ||
| * Compute whether the given x, y point is in a triangle; uses the winding order method */ | ||
| static boolean pointInTriangle(double minX, double maxX, double minY, double maxY, double x, double y, double aX, double aY, double bX, double bY, double cX, double cY) { | ||
| //check the bounding box because if the triangle is degenerated, e.g points and lines, we need to filter out | ||
| //coplanar points that are not part of the triangle. | ||
| if (x >= minX && x <= maxX && y >= minY && y <= maxY) { | ||
| int a = orient(x, y, aX, aY, bX, bY); | ||
| int b = orient(x, y, bX, bY, cX, cY); | ||
| if (a == 0 || b == 0 || a < 0 == b < 0) { | ||
| int c = orient(x, y, cX, cY, aX, aY); | ||
| return c == 0 || (c < 0 == (b < 0 || a < 0)); | ||
| } | ||
| return false; | ||
| } else { | ||
| return false; | ||
| } | ||
| } | ||
|
|
||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,206 @@ | ||
| /* | ||
| * 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.geo; | ||
|
|
||
| import java.util.Comparator; | ||
|
|
||
| import org.apache.lucene.index.PointValues.Relation; | ||
| import org.apache.lucene.util.ArrayUtil; | ||
|
|
||
| /** | ||
| * 2D multi-component geometry implementation represented as an interval tree of components. | ||
| * <p> | ||
| * Construction takes {@code O(n log n)} time for sorting and tree construction. | ||
| * | ||
| * @lucene.internal | ||
| */ | ||
| final class ComponentTree implements Component2D { | ||
| /** minimum latitude of this geometry's bounding box area */ | ||
| private double minY; | ||
| /** maximum latitude of this geometry's bounding box area */ | ||
| private double maxY; | ||
| /** minimum longitude of this geometry's bounding box area */ | ||
| private double minX; | ||
| /** maximum longitude of this geometry's bounding box area */ | ||
| private double maxX; | ||
| // child components, or null. Note internal nodes might mot have | ||
| // a consistent bounding box. Internal nodes should not be accessed | ||
| // outside if this class. | ||
| private Component2D left; | ||
| private Component2D right; | ||
| /** which dimension was this node split on */ | ||
| // TODO: its implicit based on level, but boolean keeps code simple | ||
| final private boolean splitX; | ||
| /** root node of edge tree */ | ||
| final private Component2D component; | ||
|
|
||
| protected ComponentTree(Component2D component, boolean splitX) { | ||
| this.minY = component.getMinY(); | ||
| this.maxY = component.getMaxY(); | ||
| this.minX = component.getMinX(); | ||
| this.maxX = component.getMaxX(); | ||
| this.component = component; | ||
| this.splitX = splitX; | ||
| } | ||
|
|
||
| @Override | ||
| public double getMinX() { | ||
| return minX; | ||
| } | ||
|
|
||
| @Override | ||
| public double getMaxX() { | ||
| return maxX; | ||
| } | ||
|
|
||
| @Override | ||
| public double getMinY() { | ||
| return minY; | ||
| } | ||
|
|
||
| @Override | ||
| public double getMaxY() { | ||
| return maxY; | ||
| } | ||
|
|
||
| @Override | ||
| public boolean contains(double x, double y) { | ||
| if (y <= this.maxY && x <= this.maxX) { | ||
| if (component.contains(x, y)) { | ||
| return true; | ||
| } | ||
| if (left != null) { | ||
| if (left.contains(x, y)) { | ||
| return true; | ||
| } | ||
| } | ||
| if (right != null && ((splitX == false && y >= this.component.getMinY()) || (splitX && x >= this.component.getMinX()))) { | ||
| if (right.contains(x, y)) { | ||
| return true; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
|
|
||
| /** Returns relation to the provided triangle */ | ||
| @Override | ||
| public Relation relateTriangle(double minX, double maxX, double minY, double maxY, | ||
| double ax, double ay, double bx, double by, double cx, double cy) { | ||
| if (minY <= this.maxY && minX <= this.maxX) { | ||
| Relation relation = component.relateTriangle(minX, maxX, minY, maxY, ax, ay, bx, by, cx, cy); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| if (left != null) { | ||
| relation = left.relateTriangle(minX, maxX, minY, maxY, ax, ay, bx, by, cx, cy); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| } | ||
| if (right != null && ((splitX == false && maxY >= this.component.getMinY()) || (splitX && maxX >= this.component.getMinX()))) { | ||
| relation = right.relateTriangle(minX, maxX, minY, maxY, ax, ay, bx, by, cx, cy); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| } | ||
| } | ||
| return Relation.CELL_OUTSIDE_QUERY; | ||
| } | ||
|
|
||
| /** Returns relation to the provided rectangle */ | ||
| @Override | ||
| public Relation relate(double minX, double maxX, double minY, double maxY) { | ||
| if (minY <= this.maxY && minX <= this.maxX) { | ||
| Relation relation = component.relate(minX, maxX, minY, maxY); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| if (left != null) { | ||
| relation = left.relate(minX, maxX, minY, maxY); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| } | ||
| if (right != null && ((splitX == false && maxY >= this.component.getMinY()) || (splitX && maxX >= this.component.getMinX()))) { | ||
| relation = right.relate(minX, maxX, minY, maxY); | ||
| if (relation != Relation.CELL_OUTSIDE_QUERY) { | ||
| return relation; | ||
| } | ||
| } | ||
| } | ||
| return Relation.CELL_OUTSIDE_QUERY; | ||
| } | ||
|
|
||
| /** Creates tree from provided components */ | ||
| public static Component2D create(Component2D[] components) { | ||
| if (components.length == 1) { | ||
| return components[0]; | ||
| } | ||
| ComponentTree root = createTree(components, 0, components.length - 1, false); | ||
| // pull up min values for the root node so it contains a consistent bounding box | ||
| for (Component2D component : components) { | ||
| root.minY = Math.min(root.minY, component.getMinY()); | ||
| root.minX = Math.min(root.minX, component.getMinX()); | ||
| } | ||
| return root; | ||
| } | ||
|
|
||
| /** Creates tree from sorted components (with range low and high inclusive) */ | ||
| private static ComponentTree createTree(Component2D[] components, int low, int high, boolean splitX) { | ||
| if (low > high) { | ||
| return null; | ||
| } | ||
| final int mid = (low + high) >>> 1; | ||
| if (low < high) { | ||
| Comparator<Component2D> comparator; | ||
| if (splitX) { | ||
| comparator = (left, right) -> { | ||
| int ret = Double.compare(left.getMinX(), right.getMinX()); | ||
| if (ret == 0) { | ||
| ret = Double.compare(left.getMaxX(), right.getMaxX()); | ||
| } | ||
| return ret; | ||
| }; | ||
| } else { | ||
| comparator = (left, right) -> { | ||
| int ret = Double.compare(left.getMinY(), right.getMinY()); | ||
| if (ret == 0) { | ||
| ret = Double.compare(left.getMaxY(), right.getMaxY()); | ||
| } | ||
| return ret; | ||
| }; | ||
| } | ||
| ArrayUtil.select(components, low, high + 1, mid, comparator); | ||
| } | ||
| ComponentTree newNode = new ComponentTree(components[mid], splitX); | ||
| // find children | ||
| newNode.left = createTree(components, low, mid - 1, !splitX); | ||
| newNode.right = createTree(components, mid + 1, high, !splitX); | ||
|
|
||
| // pull up max values to this node | ||
| if (newNode.left != null) { | ||
| newNode.maxX = Math.max(newNode.maxX, newNode.left.getMaxX()); | ||
| newNode.maxY = Math.max(newNode.maxY, newNode.left.getMaxY()); | ||
| } | ||
| if (newNode.right != null) { | ||
| newNode.maxX = Math.max(newNode.maxX, newNode.right.getMaxX()); | ||
| newNode.maxY = Math.max(newNode.maxY, newNode.right.getMaxY()); | ||
| } | ||
| return newNode; | ||
| } | ||
| } |
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.