You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by nk...@apache.org on 2016/02/05 21:41:28 UTC
[6/7] lucene-solr git commit: LUCENE-6997: refactor sandboxed
GeoPointField and query classes to lucene-spatial module
LUCENE-6997: refactor sandboxed GeoPointField and query classes to lucene-spatial module
Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/187fe876
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/187fe876
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/187fe876
Branch: refs/heads/branch_5x
Commit: 187fe8766a0d886499c0de5cbf61f459054002e9
Parents: d75abb2
Author: nknize <nk...@apache.org>
Authored: Fri Feb 5 10:58:39 2016 -0600
Committer: nknize <nk...@apache.org>
Committed: Fri Feb 5 14:21:40 2016 -0600
----------------------------------------------------------------------
dev-tools/idea/lucene/sandbox/sandbox.iml | 1 +
.../java/org/apache/lucene/util/SloppyMath.java | 6 +-
lucene/sandbox/build.xml | 21 +
.../lucene/bkdtree/BKDPointInPolygonQuery.java | 2 +-
.../apache/lucene/document/GeoPointField.java | 131 ----
.../org/apache/lucene/document/package.html | 28 -
.../lucene/search/GeoPointDistanceQuery.java | 174 -----
.../search/GeoPointDistanceQueryImpl.java | 131 ----
.../search/GeoPointDistanceRangeQuery.java | 101 ---
.../lucene/search/GeoPointInBBoxQuery.java | 160 ----
.../lucene/search/GeoPointInBBoxQueryImpl.java | 160 ----
.../lucene/search/GeoPointInPolygonQuery.java | 194 -----
.../apache/lucene/search/GeoPointTermQuery.java | 70 --
.../GeoPointTermQueryConstantScoreWrapper.java | 129 ----
.../apache/lucene/search/GeoPointTermsEnum.java | 249 ------
.../apache/lucene/util/GeoDistanceUtils.java | 217 ------
.../org/apache/lucene/util/GeoHashUtils.java | 273 -------
.../apache/lucene/util/GeoProjectionUtils.java | 437 -----------
.../java/org/apache/lucene/util/GeoRect.java | 66 --
.../apache/lucene/util/GeoRelationUtils.java | 497 ------------
.../java/org/apache/lucene/util/GeoUtils.java | 237 ------
.../java/org/apache/lucene/util/package.html | 28 -
.../org/apache/lucene/bkdtree/TestBKDTree.java | 4 +-
.../apache/lucene/search/TestGeoPointQuery.java | 381 ----------
.../lucene/util/BaseGeoPointTestCase.java | 755 ------------------
.../org/apache/lucene/util/TestGeoUtils.java | 545 -------------
.../lucene/spatial/document/GeoPointField.java | 136 ++++
.../lucene/spatial/document/package-info.java | 21 +
.../spatial/search/GeoPointDistanceQuery.java | 186 +++++
.../search/GeoPointDistanceQueryImpl.java | 131 ++++
.../search/GeoPointDistanceRangeQuery.java | 110 +++
.../spatial/search/GeoPointInBBoxQuery.java | 173 +++++
.../spatial/search/GeoPointInBBoxQueryImpl.java | 161 ++++
.../spatial/search/GeoPointInPolygonQuery.java | 196 +++++
.../spatial/search/GeoPointTermQuery.java | 114 +++
.../GeoPointTermQueryConstantScoreWrapper.java | 138 ++++
.../spatial/search/GeoPointTermsEnum.java | 249 ++++++
.../lucene/spatial/search/package-info.java | 21 +
.../lucene/spatial/util/GeoDistanceUtils.java | 223 ++++++
.../lucene/spatial/util/GeoHashUtils.java | 283 +++++++
.../lucene/spatial/util/GeoProjectionUtils.java | 465 ++++++++++++
.../org/apache/lucene/spatial/util/GeoRect.java | 66 ++
.../lucene/spatial/util/GeoRelationUtils.java | 520 +++++++++++++
.../apache/lucene/spatial/util/GeoUtils.java | 248 ++++++
.../spatial/search/TestGeoPointQuery.java | 384 ++++++++++
.../spatial/util/BaseGeoPointTestCase.java | 760 +++++++++++++++++++
.../lucene/spatial/util/TestGeoUtils.java | 546 +++++++++++++
47 files changed, 5159 insertions(+), 4969 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/dev-tools/idea/lucene/sandbox/sandbox.iml
----------------------------------------------------------------------
diff --git a/dev-tools/idea/lucene/sandbox/sandbox.iml b/dev-tools/idea/lucene/sandbox/sandbox.iml
index 05caa9f..47cf8da 100644
--- a/dev-tools/idea/lucene/sandbox/sandbox.iml
+++ b/dev-tools/idea/lucene/sandbox/sandbox.iml
@@ -23,6 +23,7 @@
<orderEntry type="library" scope="TEST" name="JUnit" level="project" />
<orderEntry type="module" scope="TEST" module-name="lucene-test-framework" />
<orderEntry type="module" scope="TEST" module-name="codecs" />
+ <orderEntry type="module" module-name="spatial" />
<orderEntry type="module" module-name="lucene-core" />
</component>
</module>
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/core/src/java/org/apache/lucene/util/SloppyMath.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/util/SloppyMath.java b/lucene/core/src/java/org/apache/lucene/util/SloppyMath.java
index 9a05704..8da8276 100644
--- a/lucene/core/src/java/org/apache/lucene/util/SloppyMath.java
+++ b/lucene/core/src/java/org/apache/lucene/util/SloppyMath.java
@@ -180,15 +180,15 @@ public class SloppyMath {
}
// haversin
- static final double TO_RADIANS = Math.PI / 180D;
- static final double TO_DEGREES = 180D / Math.PI;
+ public static final double TO_RADIANS = Math.PI / 180D;
+ public static final double TO_DEGREES = 180D / Math.PI;
// cos/asin
private static final double ONE_DIV_F2 = 1/2.0;
private static final double ONE_DIV_F3 = 1/6.0;
private static final double ONE_DIV_F4 = 1/24.0;
- static final double PIO2 = Math.PI / 2D;
+ public static final double PIO2 = Math.PI / 2D;
private static final double PIO2_HI = Double.longBitsToDouble(0x3FF921FB54400000L); // 1.57079632673412561417e+00 first 33 bits of pi/2
private static final double PIO2_LO = Double.longBitsToDouble(0x3DD0B4611A626331L); // 6.07710050650619224932e-11 pi/2 - PIO2_HI
private static final double TWOPI_HI = 4*PIO2_HI;
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/build.xml
----------------------------------------------------------------------
diff --git a/lucene/sandbox/build.xml b/lucene/sandbox/build.xml
index 1c44b28..abe6bbe 100644
--- a/lucene/sandbox/build.xml
+++ b/lucene/sandbox/build.xml
@@ -23,9 +23,30 @@
<import file="../module-build.xml"/>
+ <target name="compile-test-spatial" depends="init" if="module.has.tests">
+ <ant dir="${common.dir}/spatial" target="compile-test" inheritAll="false"/>
+ </target>
+
<path id="classpath">
<fileset dir="lib"/>
<path refid="base.classpath"/>
+ <pathelement path="${spatial.jar}"/>
+ </path>
+ <target name="compile-core" depends="jar-spatial,common.compile-core" />
+
+ <path id="test.classpath">
+ <pathelement location="${build.dir}/classes/java"/>
+ <pathelement location="${build.dir}/classes/test"/>
+ <pathelement location="${common.dir}/build/spatial/classes/test"/>
+ <path refid="test.base.classpath"/>
+ <pathelement path="${spatial.jar}"/>
+ <path refid="junit-path"/>
+ </path>
+
+ <path id="junit.classpath">
+ <path refid="test.classpath"/>
+ <pathelement path="${java.class.path}"/>
</path>
+ <target name="compile-test" depends="jar-spatial,compile-test-spatial,common.compile-test" />
</project>
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/bkdtree/BKDPointInPolygonQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/bkdtree/BKDPointInPolygonQuery.java b/lucene/sandbox/src/java/org/apache/lucene/bkdtree/BKDPointInPolygonQuery.java
index 76a6e4f..839bb0c 100644
--- a/lucene/sandbox/src/java/org/apache/lucene/bkdtree/BKDPointInPolygonQuery.java
+++ b/lucene/sandbox/src/java/org/apache/lucene/bkdtree/BKDPointInPolygonQuery.java
@@ -30,7 +30,7 @@ import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Scorer;
import org.apache.lucene.search.Weight;
-import org.apache.lucene.util.GeoRelationUtils;
+import org.apache.lucene.spatial.util.GeoRelationUtils;
/** Finds all previously indexed points that fall within the specified polygon.
*
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/document/GeoPointField.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/document/GeoPointField.java b/lucene/sandbox/src/java/org/apache/lucene/document/GeoPointField.java
deleted file mode 100644
index f372942..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/document/GeoPointField.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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.document;
-
-import org.apache.lucene.index.DocValuesType;
-import org.apache.lucene.index.IndexOptions;
-import org.apache.lucene.util.GeoUtils;
-
-/**
- * <p>
- * Field that indexes <code>latitude</code> <code>longitude</code> decimal-degree values
- * for efficient encoding, sorting, and querying. This Geo capability is intended
- * to provide a basic and efficient out of the box field type for indexing and
- * querying 2 dimensional points in WGS-84 decimal degrees. An example usage is as follows:
- *
- * <pre class="prettyprint">
- * document.add(new GeoPointField(name, -96.33, 32.66, Field.Store.NO));
- * </pre>
- *
- * <p>To perform simple geospatial queries against a <code>GeoPointField</code>,
- * see {@link org.apache.lucene.search.GeoPointInBBoxQuery}, {@link org.apache.lucene.search.GeoPointInPolygonQuery},
- * or {@link org.apache.lucene.search.GeoPointDistanceQuery}
- *
- * NOTE: This indexes only high precision encoded terms which may result in visiting a high number
- * of terms for large queries. See LUCENE-6481 for a future improvement.
- *
- * @lucene.experimental
- */
-public final class GeoPointField extends Field {
- public static final int PRECISION_STEP = 9;
-
- /**
- * Type for an GeoPointField that is not stored:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final FieldType TYPE_NOT_STORED = new FieldType();
- static {
- TYPE_NOT_STORED.setTokenized(false);
- TYPE_NOT_STORED.setOmitNorms(true);
- TYPE_NOT_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_NOT_STORED.setDocValuesType(DocValuesType.SORTED_NUMERIC);
- TYPE_NOT_STORED.setNumericType(FieldType.NumericType.LONG);
- TYPE_NOT_STORED.setNumericPrecisionStep(PRECISION_STEP);
- TYPE_NOT_STORED.freeze();
- }
-
- /**
- * Type for a stored GeoPointField:
- * normalization factors, frequencies, and positions are omitted.
- */
- public static final FieldType TYPE_STORED = new FieldType();
- static {
- TYPE_STORED.setTokenized(false);
- TYPE_STORED.setOmitNorms(true);
- TYPE_STORED.setIndexOptions(IndexOptions.DOCS);
- TYPE_STORED.setDocValuesType(DocValuesType.SORTED_NUMERIC);
- TYPE_STORED.setNumericType(FieldType.NumericType.LONG);
- TYPE_STORED.setNumericPrecisionStep(PRECISION_STEP);
- TYPE_STORED.setStored(true);
- TYPE_STORED.freeze();
- }
-
- /** Creates a stored or un-stored GeoPointField with the provided value
- * and default <code>precisionStep</code> set to 64 to avoid wasteful
- * indexing of lower precision terms.
- * @param name field name
- * @param lon longitude double value [-180.0 : 180.0]
- * @param lat latitude double value [-90.0 : 90.0]
- * @param stored Store.YES if the content should also be stored
- * @throws IllegalArgumentException if the field name is null.
- */
- public GeoPointField(String name, double lon, double lat, Store stored) {
- super(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED);
- fieldsData = GeoUtils.mortonHash(lon, lat);
- }
-
- /** Expert: allows you to customize the {@link
- * FieldType}.
- * @param name field name
- * @param lon longitude double value [-180.0 : 180.0]
- * @param lat latitude double value [-90.0 : 90.0]
- * @param type customized field type: must have {@link FieldType#numericType()}
- * of {@link FieldType.NumericType#LONG}.
- * @throws IllegalArgumentException if the field name or type is null, or
- * if the field type does not have a LONG numericType()
- */
- public GeoPointField(String name, double lon, double lat, FieldType type) {
- super(name, type);
- if (type.numericType() != FieldType.NumericType.LONG) {
- throw new IllegalArgumentException("type.numericType() must be LONG but got " + type.numericType());
- }
- if (type.docValuesType() != DocValuesType.SORTED_NUMERIC) {
- throw new IllegalArgumentException("type.docValuesType() must be SORTED_NUMERIC but got " + type.docValuesType());
- }
- fieldsData = GeoUtils.mortonHash(lon, lat);
- }
-
- public double getLon() {
- return GeoUtils.mortonUnhashLon((long) fieldsData);
- }
-
- public double getLat() {
- return GeoUtils.mortonUnhashLat((long) fieldsData);
- }
-
- @Override
- public String toString() {
- if (fieldsData == null) {
- return null;
- }
- StringBuilder sb = new StringBuilder();
- sb.append(GeoUtils.mortonUnhashLon((long) fieldsData));
- sb.append(',');
- sb.append(GeoUtils.mortonUnhashLat((long) fieldsData));
- return sb.toString();
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/document/package.html
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/document/package.html b/lucene/sandbox/src/java/org/apache/lucene/document/package.html
deleted file mode 100644
index 6f26128..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/document/package.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<!--
- 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.
--->
-
-<!-- not a package-info.java, because we already defined this package in core/ -->
-
-<html>
-<head>
- <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-</head>
-<body>
-This package contains a single Field implementation, GeoPointField, to index a lat/lon geospatial point.
-</body>
-</html>
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQuery.java
deleted file mode 100644
index ae54b4f..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQuery.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.util.GeoDistanceUtils;
-import org.apache.lucene.util.GeoRect;
-import org.apache.lucene.util.GeoUtils;
-
-/** Implements a simple point distance query on a GeoPoint field. This is based on
- * {@link org.apache.lucene.search.GeoPointInBBoxQuery} and is implemented using a two phase approach. First,
- * like {@code GeoPointInBBoxQueryImpl} candidate terms are queried using the numeric ranges based on
- * the morton codes of the min and max lat/lon pairs that intersect the boundary of the point-radius
- * circle. Terms
- * passing this initial filter are then passed to a secondary {@code postFilter} method that verifies whether the
- * decoded lat/lon point fall within the specified query distance (see {@link org.apache.lucene.util.SloppyMath#haversin}.
- * All morton value comparisons are subject to the same precision tolerance defined in
- * {@value org.apache.lucene.util.GeoUtils#TOLERANCE} and distance comparisons are subject to the accuracy of the
- * haversine formula (from R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159)
- *
- * <p>Note: This query currently uses haversine which is a sloppy distance calculation (see above reference). For large
- * queries one can expect upwards of 400m error. Vincenty shrinks this to ~40m error but pays a penalty for computing
- * using the spheroid
- *
- * @lucene.experimental */
-public class GeoPointDistanceQuery extends GeoPointInBBoxQuery {
- protected final double centerLon;
- protected final double centerLat;
- protected final double radiusMeters;
-
- /** NOTE: radius is in meters. */
- public GeoPointDistanceQuery(final String field, final double centerLon, final double centerLat, final double radiusMeters) {
- this(field, GeoUtils.circleToBBox(centerLon, centerLat, radiusMeters), centerLon, centerLat, radiusMeters);
- }
-
- private GeoPointDistanceQuery(final String field, GeoRect bbox, final double centerLon,
- final double centerLat, final double radiusMeters) {
- super(field, bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat);
- {
- // check longitudinal overlap (limits radius)
- final double maxRadius = GeoDistanceUtils.maxRadialDistanceMeters(centerLon, centerLat);
- if (radiusMeters > maxRadius) {
- throw new IllegalArgumentException("radiusMeters " + radiusMeters + " exceeds maxRadius [" + maxRadius
- + "] at location [" + centerLon + " " + centerLat + "]");
- }
- }
-
- if (GeoUtils.isValidLon(centerLon) == false) {
- throw new IllegalArgumentException("invalid centerLon " + centerLon);
- }
-
- if (GeoUtils.isValidLat(centerLat) == false) {
- throw new IllegalArgumentException("invalid centerLat " + centerLat);
- }
-
- if (radiusMeters <= 0.0) {
- throw new IllegalArgumentException("invalid radiusMeters " + radiusMeters);
- }
-
- this.centerLon = centerLon;
- this.centerLat = centerLat;
- this.radiusMeters = radiusMeters;
- }
-
- @Override
- public Query rewrite(IndexReader reader) throws IOException {
- if (getBoost() != 1f) {
- return super.rewrite(reader);
- }
- // query crosses dateline; split into left and right queries
- if (maxLon < minLon) {
- BooleanQuery.Builder bqb = new BooleanQuery.Builder();
-
- // unwrap the longitude iff outside the specified min/max lon range
- double unwrappedLon = centerLon;
- if (unwrappedLon > maxLon) {
- // unwrap left
- unwrappedLon += -360.0D;
- }
- GeoPointDistanceQueryImpl left = new GeoPointDistanceQueryImpl(field, this, unwrappedLon,
- new GeoRect(GeoUtils.MIN_LON_INCL, maxLon, minLat, maxLat));
- bqb.add(new BooleanClause(left, BooleanClause.Occur.SHOULD));
-
- if (unwrappedLon < maxLon) {
- // unwrap right
- unwrappedLon += 360.0D;
- }
- GeoPointDistanceQueryImpl right = new GeoPointDistanceQueryImpl(field, this, unwrappedLon,
- new GeoRect(minLon, GeoUtils.MAX_LON_INCL, minLat, maxLat));
- bqb.add(new BooleanClause(right, BooleanClause.Occur.SHOULD));
-
- return bqb.build();
- }
- return new GeoPointDistanceQueryImpl(field, this, centerLon, new GeoRect(this.minLon, this.maxLon, this.minLat, this.maxLat));
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof GeoPointDistanceQuery)) return false;
- if (!super.equals(o)) return false;
-
- GeoPointDistanceQuery that = (GeoPointDistanceQuery) o;
-
- if (Double.compare(that.centerLat, centerLat) != 0) return false;
- if (Double.compare(that.centerLon, centerLon) != 0) return false;
- if (Double.compare(that.radiusMeters, radiusMeters) != 0) return false;
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- long temp;
- temp = Double.doubleToLongBits(centerLon);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(centerLat);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(radiusMeters);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- return result;
- }
-
- @Override
- public String toString(String field) {
- final StringBuilder sb = new StringBuilder();
- sb.append(getClass().getSimpleName());
- sb.append(':');
- if (!this.field.equals(field)) {
- sb.append(" field=");
- sb.append(this.field);
- sb.append(':');
- }
- return sb.append( " Center: [")
- .append(centerLon)
- .append(',')
- .append(centerLat)
- .append(']')
- .append(" Distance: ")
- .append(radiusMeters)
- .append(" meters")
- .append("]")
- .toString();
- }
-
- public double getCenterLon() {
- return this.centerLon;
- }
-
- public double getCenterLat() {
- return this.centerLat;
- }
-
- public double getRadiusMeters() {
- return this.radiusMeters;
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQueryImpl.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQueryImpl.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQueryImpl.java
deleted file mode 100644
index ef2155b..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceQueryImpl.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.document.GeoPointField;
-import org.apache.lucene.index.Terms;
-import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.util.AttributeSource;
-import org.apache.lucene.util.GeoRect;
-import org.apache.lucene.util.GeoRelationUtils;
-import org.apache.lucene.util.GeoUtils;
-import org.apache.lucene.util.SloppyMath;
-
-/** Package private implementation for the public facing GeoPointDistanceQuery delegate class.
- *
- * @lucene.experimental
- */
-final class GeoPointDistanceQueryImpl extends GeoPointInBBoxQueryImpl {
- private final GeoPointDistanceQuery query;
- private final double centerLon;
-
- GeoPointDistanceQueryImpl(final String field, final GeoPointDistanceQuery q, final double centerLonUnwrapped,
- final GeoRect bbox) {
- super(field, bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat);
- query = q;
- centerLon = centerLonUnwrapped;
- }
-
- @Override @SuppressWarnings("unchecked")
- protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException {
- return new GeoPointRadiusTermsEnum(terms.iterator(), this.minLon, this.minLat, this.maxLon, this.maxLat);
- }
-
- @Override
- public void setRewriteMethod(RewriteMethod method) {
- throw new UnsupportedOperationException("cannot change rewrite method");
- }
-
- private final class GeoPointRadiusTermsEnum extends GeoPointTermsEnum {
- GeoPointRadiusTermsEnum(final TermsEnum tenum, final double minLon, final double minLat,
- final double maxLon, final double maxLat) {
- super(tenum, minLon, minLat, maxLon, maxLat);
- }
-
- /**
- * Computes the maximum shift for the given pointDistanceQuery. This prevents unnecessary depth traversal
- * given the size of the distance query.
- */
- @Override
- protected short computeMaxShift() {
- final short shiftFactor;
-
- if (query.radiusMeters > 1000000) {
- shiftFactor = 5;
- } else {
- shiftFactor = 4;
- }
-
- return (short)(GeoPointField.PRECISION_STEP * shiftFactor);
- }
-
- @Override
- protected boolean cellCrosses(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectCrossesCircle(minLon, minLat, maxLon, maxLat,
- centerLon, query.centerLat, query.radiusMeters, true);
- }
-
- @Override
- protected boolean cellWithin(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectWithinCircle(minLon, minLat, maxLon, maxLat,
- centerLon, query.centerLat, query.radiusMeters, true);
- }
-
- @Override
- protected boolean cellIntersectsShape(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return (cellContains(minLon, minLat, maxLon, maxLat)
- || cellWithin(minLon, minLat, maxLon, maxLat) || cellCrosses(minLon, minLat, maxLon, maxLat));
- }
-
- /**
- * The two-phase query approach. The parent {@link org.apache.lucene.search.GeoPointTermsEnum} class matches
- * encoded terms that fall within the minimum bounding box of the point-radius circle. Those documents that pass
- * the initial bounding box filter are then post filter compared to the provided distance using the
- * {@link org.apache.lucene.util.SloppyMath#haversin} method.
- */
- @Override
- protected boolean postFilter(final double lon, final double lat) {
- return (SloppyMath.haversin(query.centerLat, centerLon, lat, lon) * 1000.0 <= query.radiusMeters);
- }
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof GeoPointDistanceQueryImpl)) return false;
- if (!super.equals(o)) return false;
-
- GeoPointDistanceQueryImpl that = (GeoPointDistanceQueryImpl) o;
-
- if (!query.equals(that.query)) return false;
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- result = 31 * result + query.hashCode();
- return result;
- }
-
- public double getRadiusMeters() {
- return query.getRadiusMeters();
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceRangeQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceRangeQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceRangeQuery.java
deleted file mode 100644
index 3cfc9fd..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointDistanceRangeQuery.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.index.IndexReader;
-
-/** Implements a point distance range query on a GeoPoint field. This is based on
- * {@code org.apache.lucene.search.GeoPointDistanceQuery} and is implemented using a
- * {@code org.apache.lucene.search.BooleanClause.MUST_NOT} clause to exclude any points that fall within
- * minRadiusMeters from the provided point.
- *
- * @lucene.experimental
- */
-public final class GeoPointDistanceRangeQuery extends GeoPointDistanceQuery {
- protected final double minRadiusMeters;
-
- public GeoPointDistanceRangeQuery(final String field, final double centerLon, final double centerLat,
- final double minRadiusMeters, final double maxRadius) {
- super(field, centerLon, centerLat, maxRadius);
- this.minRadiusMeters = minRadiusMeters;
- }
-
- @Override
- public Query rewrite(IndexReader reader) throws IOException {
- if (getBoost() != 1f) {
- return super.rewrite(reader);
- }
- Query q = super.rewrite(reader);
- if (minRadiusMeters == 0.0) {
- return q;
- }
-
- // add an exclusion query
- BooleanQuery.Builder bqb = new BooleanQuery.Builder();
-
- // create a new exclusion query
- GeoPointDistanceQuery exclude = new GeoPointDistanceQuery(field, centerLon, centerLat, minRadiusMeters);
- bqb.add(new BooleanClause(q, BooleanClause.Occur.MUST));
- bqb.add(new BooleanClause(exclude, BooleanClause.Occur.MUST_NOT));
-
- return bqb.build();
- }
-
- @Override
- public String toString(String field) {
- final StringBuilder sb = new StringBuilder();
- sb.append(getClass().getSimpleName());
- sb.append(':');
- if (!this.field.equals(field)) {
- sb.append(" field=");
- sb.append(this.field);
- sb.append(':');
- }
- return sb.append( " Center: [")
- .append(centerLon)
- .append(',')
- .append(centerLat)
- .append(']')
- .append(" From Distance: ")
- .append(minRadiusMeters)
- .append(" m")
- .append(" To Distance: ")
- .append(radiusMeters)
- .append(" m")
- .append(" Lower Left: [")
- .append(minLon)
- .append(',')
- .append(minLat)
- .append(']')
- .append(" Upper Right: [")
- .append(maxLon)
- .append(',')
- .append(maxLat)
- .append("]")
- .toString();
- }
-
- public double getMinRadiusMeters() {
- return this.minRadiusMeters;
- }
-
- public double getMaxRadiusMeters() {
- return this.radiusMeters;
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQuery.java
deleted file mode 100644
index 71bfb79..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQuery.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.util.GeoUtils;
-import org.apache.lucene.util.ToStringUtils;
-
-/** Implements a simple bounding box query on a GeoPoint field. This is inspired by
- * {@link org.apache.lucene.search.NumericRangeQuery} and is implemented using a
- * two phase approach. First, candidate terms are queried using a numeric
- * range based on the morton codes of the min and max lat/lon pairs. Terms
- * passing this initial filter are passed to a final check that verifies whether
- * the decoded lat/lon falls within (or on the boundary) of the query bounding box.
- * The value comparisons are subject to a precision tolerance defined in
- * {@value org.apache.lucene.util.GeoUtils#TOLERANCE}
- *
- * NOTES:
- * 1. All latitude/longitude values must be in decimal degrees.
- * 2. Complex computational geometry (e.g., dateline wrapping) is not supported
- * 3. For more advanced GeoSpatial indexing and query operations see spatial module
- * 4. This is well suited for small rectangles, large bounding boxes may result
- * in many terms, depending whether the bounding box falls on the boundary of
- * many cells (degenerate case)
- *
- * @lucene.experimental
- */
-public class GeoPointInBBoxQuery extends Query {
- protected final String field;
- protected final double minLon;
- protected final double minLat;
- protected final double maxLon;
- protected final double maxLat;
-
- public GeoPointInBBoxQuery(final String field, final double minLon, final double minLat, final double maxLon, final double maxLat) {
- this.field = field;
- this.minLon = minLon;
- this.minLat = minLat;
- this.maxLon = maxLon;
- this.maxLat = maxLat;
- }
-
- @Override
- public Query rewrite(IndexReader reader) throws IOException {
- if (getBoost() != 1f) {
- return super.rewrite(reader);
- }
-
- // short-circuit to match all if specifying the whole map
- if (minLon == GeoUtils.MIN_LON_INCL && maxLon == GeoUtils.MAX_LON_INCL
- && minLat == GeoUtils.MIN_LAT_INCL && maxLat == GeoUtils.MAX_LAT_INCL) {
- // FieldValueQuery is valid since DocValues are *required* for GeoPointField
- return new FieldValueQuery(field);
- }
-
- if (maxLon < minLon) {
- BooleanQuery.Builder bq = new BooleanQuery.Builder();
-
- GeoPointInBBoxQueryImpl left = new GeoPointInBBoxQueryImpl(field, -180.0D, minLat, maxLon, maxLat);
- bq.add(new BooleanClause(left, BooleanClause.Occur.SHOULD));
- GeoPointInBBoxQueryImpl right = new GeoPointInBBoxQueryImpl(field, minLon, minLat, 180.0D, maxLat);
- bq.add(new BooleanClause(right, BooleanClause.Occur.SHOULD));
- return bq.build();
- }
- return new GeoPointInBBoxQueryImpl(field, minLon, minLat, maxLon, maxLat);
- }
-
- @Override
- public String toString(String field) {
- final StringBuilder sb = new StringBuilder();
- sb.append(getClass().getSimpleName());
- sb.append(':');
- if (!this.field.equals(field)) {
- sb.append(" field=");
- sb.append(this.field);
- sb.append(':');
- }
- return sb.append(" Lower Left: [")
- .append(minLon)
- .append(',')
- .append(minLat)
- .append(']')
- .append(" Upper Right: [")
- .append(maxLon)
- .append(',')
- .append(maxLat)
- .append("]")
- .append(ToStringUtils.boost(getBoost()))
- .toString();
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof GeoPointInBBoxQuery)) return false;
- if (!super.equals(o)) return false;
-
- GeoPointInBBoxQuery that = (GeoPointInBBoxQuery) o;
-
- if (Double.compare(that.maxLat, maxLat) != 0) return false;
- if (Double.compare(that.maxLon, maxLon) != 0) return false;
- if (Double.compare(that.minLat, minLat) != 0) return false;
- if (Double.compare(that.minLon, minLon) != 0) return false;
- if (!field.equals(that.field)) return false;
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- long temp;
- result = 31 * result + field.hashCode();
- temp = Double.doubleToLongBits(minLon);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(minLat);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(maxLon);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(maxLat);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- return result;
- }
-
- public final String getField() {
- return this.field;
- }
-
- public final double getMinLon() {
- return this.minLon;
- }
-
- public final double getMinLat() {
- return this.minLat;
- }
-
- public final double getMaxLon() {
- return this.maxLon;
- }
-
- public final double getMaxLat() {
- return this.maxLat;
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQueryImpl.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQueryImpl.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQueryImpl.java
deleted file mode 100644
index b385a54..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInBBoxQueryImpl.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.document.GeoPointField;
-import org.apache.lucene.index.Terms;
-import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.util.AttributeSource;
-import org.apache.lucene.util.GeoRelationUtils;
-import org.apache.lucene.util.SloppyMath;
-
-/** Package private implementation for the public facing GeoPointInBBoxQuery delegate class.
- *
- * @lucene.experimental
- */
-class GeoPointInBBoxQueryImpl extends GeoPointTermQuery {
- /**
- * Constructs a new GeoBBoxQuery that will match encoded GeoPoint terms that fall within or on the boundary
- * of the bounding box defined by the input parameters
- * @param field the field name
- * @param minLon lower longitude (x) value of the bounding box
- * @param minLat lower latitude (y) value of the bounding box
- * @param maxLon upper longitude (x) value of the bounding box
- * @param maxLat upper latitude (y) value of the bounding box
- */
- GeoPointInBBoxQueryImpl(final String field, final double minLon, final double minLat, final double maxLon, final double maxLat) {
- super(field, minLon, minLat, maxLon, maxLat);
- }
-
- @Override @SuppressWarnings("unchecked")
- protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException {
- return new GeoPointInBBoxTermsEnum(terms.iterator(), minLon, minLat, maxLon, maxLat);
- }
-
- @Override
- public void setRewriteMethod(RewriteMethod method) {
- throw new UnsupportedOperationException("cannot change rewrite method");
- }
-
- protected class GeoPointInBBoxTermsEnum extends GeoPointTermsEnum {
- protected GeoPointInBBoxTermsEnum(final TermsEnum tenum, final double minLon, final double minLat,
- final double maxLon, final double maxLat) {
- super(tenum, minLon, minLat, maxLon, maxLat);
- }
-
- @Override
- protected short computeMaxShift() {
- final short shiftFactor;
-
- // compute diagonal radius
- double midLon = (minLon + maxLon) * 0.5;
- double midLat = (minLat + maxLat) * 0.5;
-
- if (SloppyMath.haversin(minLat, minLon, midLat, midLon)*1000 > 1000000) {
- shiftFactor = 5;
- } else {
- shiftFactor = 4;
- }
-
- return (short)(GeoPointField.PRECISION_STEP * shiftFactor);
- }
-
- /**
- * Determine whether the quad-cell crosses the shape
- */
- @Override
- protected boolean cellCrosses(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectCrosses(minLon, minLat, maxLon, maxLat, this.minLon, this.minLat, this.maxLon, this.maxLat);
- }
-
- /**
- * Determine whether quad-cell is within the shape
- */
- @Override
- protected boolean cellWithin(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectWithin(minLon, minLat, maxLon, maxLat, this.minLon, this.minLat, this.maxLon, this.maxLat);
- }
-
- @Override
- protected boolean cellIntersectsShape(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return cellIntersectsMBR(minLon, minLat, maxLon, maxLat);
- }
-
- @Override
- protected boolean postFilter(final double lon, final double lat) {
- return GeoRelationUtils.pointInRectPrecise(lon, lat, minLon, minLat, maxLon, maxLat);
- }
- }
-
- @Override
- @SuppressWarnings({"unchecked","rawtypes"})
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- if (!super.equals(o)) return false;
-
- GeoPointInBBoxQueryImpl that = (GeoPointInBBoxQueryImpl) o;
-
- if (Double.compare(that.maxLat, maxLat) != 0) return false;
- if (Double.compare(that.maxLon, maxLon) != 0) return false;
- if (Double.compare(that.minLat, minLat) != 0) return false;
- if (Double.compare(that.minLon, minLon) != 0) return false;
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- long temp;
- temp = Double.doubleToLongBits(minLon);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(minLat);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(maxLon);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- temp = Double.doubleToLongBits(maxLat);
- result = 31 * result + (int) (temp ^ (temp >>> 32));
- return result;
- }
-
- @Override
- public String toString(String field) {
- final StringBuilder sb = new StringBuilder();
- sb.append(getClass().getSimpleName());
- sb.append(':');
- if (!getField().equals(field)) {
- sb.append(" field=");
- sb.append(getField());
- sb.append(':');
- }
- return sb.append(" Lower Left: [")
- .append(minLon)
- .append(',')
- .append(minLat)
- .append(']')
- .append(" Upper Right: [")
- .append(maxLon)
- .append(',')
- .append(maxLat)
- .append("]")
- .toString();
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInPolygonQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInPolygonQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInPolygonQuery.java
deleted file mode 100644
index abdcf95..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointInPolygonQuery.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-import java.util.Arrays;
-
-import org.apache.lucene.index.Terms;
-import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.util.AttributeSource;
-import org.apache.lucene.util.GeoRect;
-import org.apache.lucene.util.GeoRelationUtils;
-import org.apache.lucene.util.GeoUtils;
-
-/** Implements a simple point in polygon query on a GeoPoint field. This is based on
- * {@code GeoPointInBBoxQueryImpl} and is implemented using a
- * three phase approach. First, like {@code GeoPointInBBoxQueryImpl}
- * candidate terms are queried using a numeric range based on the morton codes
- * of the min and max lat/lon pairs. Terms passing this initial filter are passed
- * to a secondary filter that verifies whether the decoded lat/lon point falls within
- * (or on the boundary) of the bounding box query. Finally, the remaining candidate
- * term is passed to the final point in polygon check. All value comparisons are subject
- * to the same precision tolerance defined in {@value org.apache.lucene.util.GeoUtils#TOLERANCE}
- *
- * <p>NOTES:
- * 1. The polygon coordinates need to be in either clockwise or counter-clockwise order.
- * 2. The polygon must not be self-crossing, otherwise the query may result in unexpected behavior
- * 3. All latitude/longitude values must be in decimal degrees.
- * 4. Complex computational geometry (e.g., dateline wrapping, polygon with holes) is not supported
- * 5. For more advanced GeoSpatial indexing and query operations see spatial module
- *
- * @lucene.experimental
- */
-public final class GeoPointInPolygonQuery extends GeoPointInBBoxQueryImpl {
- // polygon position arrays - this avoids the use of any objects or
- // or geo library dependencies
- private final double[] x;
- private final double[] y;
-
- /**
- * Constructs a new GeoPolygonQuery that will match encoded {@link org.apache.lucene.document.GeoPointField} terms
- * that fall within or on the boundary of the polygon defined by the input parameters.
- */
- public GeoPointInPolygonQuery(final String field, final double[] polyLons, final double[] polyLats) {
- this(field, GeoUtils.polyToBBox(polyLons, polyLats), polyLons, polyLats);
- }
-
- /** Common constructor, used only internally. */
- private GeoPointInPolygonQuery(final String field, GeoRect bbox, final double[] polyLons, final double[] polyLats) {
- super(field, bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat);
- if (polyLats.length != polyLons.length) {
- throw new IllegalArgumentException("polyLats and polyLons must be equal length");
- }
- if (polyLats.length < 4) {
- throw new IllegalArgumentException("at least 4 polygon points required");
- }
- if (polyLats[0] != polyLats[polyLats.length-1]) {
- throw new IllegalArgumentException("first and last points of the polygon must be the same (it must close itself): polyLats[0]=" + polyLats[0] + " polyLats[" + (polyLats.length-1) + "]=" + polyLats[polyLats.length-1]);
- }
- if (polyLons[0] != polyLons[polyLons.length-1]) {
- throw new IllegalArgumentException("first and last points of the polygon must be the same (it must close itself): polyLons[0]=" + polyLons[0] + " polyLons[" + (polyLons.length-1) + "]=" + polyLons[polyLons.length-1]);
- }
-
- this.x = polyLons;
- this.y = polyLats;
- }
-
- @Override @SuppressWarnings("unchecked")
- protected TermsEnum getTermsEnum(final Terms terms, AttributeSource atts) throws IOException {
- return new GeoPolygonTermsEnum(terms.iterator(), this.minLon, this.minLat, this.maxLon, this.maxLat);
- }
-
- @Override
- public void setRewriteMethod(RewriteMethod method) {
- throw new UnsupportedOperationException("cannot change rewrite method");
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- if (!super.equals(o)) return false;
-
- GeoPointInPolygonQuery that = (GeoPointInPolygonQuery) o;
-
- if (!Arrays.equals(x, that.x)) return false;
- if (!Arrays.equals(y, that.y)) return false;
-
- return true;
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- result = 31 * result + (x != null ? Arrays.hashCode(x) : 0);
- result = 31 * result + (y != null ? Arrays.hashCode(y) : 0);
- return result;
- }
-
- @Override
- public String toString(String field) {
- assert x.length == y.length;
-
- final StringBuilder sb = new StringBuilder();
- sb.append(getClass().getSimpleName());
- sb.append(':');
- if (!getField().equals(field)) {
- sb.append(" field=");
- sb.append(getField());
- sb.append(':');
- }
- sb.append(" Points: ");
- for (int i=0; i<x.length; ++i) {
- sb.append("[")
- .append(x[i])
- .append(", ")
- .append(y[i])
- .append("] ");
- }
-
- return sb.toString();
- }
-
- /**
- * Custom {@link org.apache.lucene.index.TermsEnum} that computes morton hash ranges based on the defined edges of
- * the provided polygon.
- */
- private final class GeoPolygonTermsEnum extends GeoPointTermsEnum {
- GeoPolygonTermsEnum(final TermsEnum tenum, final double minLon, final double minLat,
- final double maxLon, final double maxLat) {
- super(tenum, minLon, minLat, maxLon, maxLat);
- }
-
- @Override
- protected boolean cellCrosses(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectCrossesPolyApprox(minLon, minLat, maxLon, maxLat, x, y, GeoPointInPolygonQuery.this.minLon,
- GeoPointInPolygonQuery.this.minLat, GeoPointInPolygonQuery.this.maxLon, GeoPointInPolygonQuery.this.maxLat);
- }
-
- @Override
- protected boolean cellWithin(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectWithinPolyApprox(minLon, minLat, maxLon, maxLat, x, y, GeoPointInPolygonQuery.this.minLon,
- GeoPointInPolygonQuery.this.minLat, GeoPointInPolygonQuery.this.maxLon, GeoPointInPolygonQuery.this.maxLat);
- }
-
- @Override
- protected boolean cellIntersectsShape(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return cellContains(minLon, minLat, maxLon, maxLat) || cellWithin(minLon, minLat, maxLon, maxLat)
- || cellCrosses(minLon, minLat, maxLon, maxLat);
- }
-
- /**
- * The two-phase query approach. The parent
- * {@link org.apache.lucene.search.GeoPointTermsEnum#accept} method is called to match
- * encoded terms that fall within the bounding box of the polygon. Those documents that pass the initial
- * bounding box filter are then compared to the provided polygon using the
- * {@link org.apache.lucene.util.GeoRelationUtils#pointInPolygon} method.
- */
- @Override
- protected boolean postFilter(final double lon, final double lat) {
- return GeoRelationUtils.pointInPolygon(x, y, lat, lon);
- }
- }
-
- /**
- * API utility method for returning the array of longitudinal values for this GeoPolygon
- * The returned array is not a copy so do not change it!
- */
- public double[] getLons() {
- return this.x;
- }
-
- /**
- * API utility method for returning the array of latitudinal values for this GeoPolygon
- * The returned array is not a copy so do not change it!
- */
- public double[] getLats() {
- return this.y;
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQuery.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQuery.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQuery.java
deleted file mode 100644
index 5ec0774..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQuery.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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.search;
-
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.util.GeoUtils;
-
-/**
- * TermQuery for GeoPointField for overriding {@link org.apache.lucene.search.MultiTermQuery} methods specific to
- * Geospatial operations
- *
- * @lucene.experimental
- */
-abstract class GeoPointTermQuery extends MultiTermQuery {
- // simple bounding box optimization - no objects used to avoid dependencies
- protected final double minLon;
- protected final double minLat;
- protected final double maxLon;
- protected final double maxLat;
-
- /**
- * Constructs a query matching terms that cannot be represented with a single
- * Term.
- */
- public GeoPointTermQuery(String field, final double minLon, final double minLat, final double maxLon, final double maxLat) {
- super(field);
-
- if (GeoUtils.isValidLon(minLon) == false) {
- throw new IllegalArgumentException("invalid minLon " + minLon);
- }
- if (GeoUtils.isValidLon(maxLon) == false) {
- throw new IllegalArgumentException("invalid maxLon " + maxLon);
- }
- if (GeoUtils.isValidLat(minLat) == false) {
- throw new IllegalArgumentException("invalid minLat " + minLat);
- }
- if (GeoUtils.isValidLat(maxLat) == false) {
- throw new IllegalArgumentException("invalid maxLat " + maxLat);
- }
- this.minLon = minLon;
- this.minLat = minLat;
- this.maxLon = maxLon;
- this.maxLat = maxLat;
-
- this.rewriteMethod = GEO_CONSTANT_SCORE_REWRITE;
- }
-
- public static final RewriteMethod GEO_CONSTANT_SCORE_REWRITE = new RewriteMethod() {
- @Override
- public Query rewrite(IndexReader reader, MultiTermQuery query) {
- return new GeoPointTermQueryConstantScoreWrapper<>((GeoPointTermQuery)query);
- }
- };
-
-
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQueryConstantScoreWrapper.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQueryConstantScoreWrapper.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQueryConstantScoreWrapper.java
deleted file mode 100644
index e00bb72..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermQueryConstantScoreWrapper.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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.search;
-
-import java.io.IOException;
-
-import org.apache.lucene.index.LeafReader;
-import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.PostingsEnum;
-import org.apache.lucene.index.SortedNumericDocValues;
-import org.apache.lucene.index.Terms;
-import org.apache.lucene.util.DocIdSetBuilder;
-import org.apache.lucene.util.GeoUtils;
-
-/**
- * Custom ConstantScoreWrapper for {@code GeoPointTermQuery} that cuts over to DocValues
- * for post filtering boundary ranges. Multi-valued GeoPoint documents are supported.
- *
- * @lucene.experimental
- */
-final class GeoPointTermQueryConstantScoreWrapper <Q extends GeoPointTermQuery> extends Query {
- protected final Q query;
-
- protected GeoPointTermQueryConstantScoreWrapper(Q query) {
- this.query = query;
- }
-
- @Override
- public String toString(String field) {
- return query.toString();
- }
-
- @Override
- public final boolean equals(final Object o) {
- if (super.equals(o) == false) {
- return false;
- }
- final GeoPointTermQueryConstantScoreWrapper<?> that = (GeoPointTermQueryConstantScoreWrapper<?>) o;
- return this.query.equals(that.query);
- }
-
- @Override
- public final int hashCode() {
- return 31 * super.hashCode() + query.hashCode();
- }
-
- @Override
- public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
- return new ConstantScoreWeight(this) {
-
- private DocIdSet getDocIDs(LeafReaderContext context) throws IOException {
- final Terms terms = context.reader().terms(query.field);
- if (terms == null) {
- return DocIdSet.EMPTY;
- }
-
- final GeoPointTermsEnum termsEnum = (GeoPointTermsEnum)(query.getTermsEnum(terms));
- assert termsEnum != null;
-
- LeafReader reader = context.reader();
- DocIdSetBuilder builder = new DocIdSetBuilder(reader.maxDoc());
- PostingsEnum docs = null;
- SortedNumericDocValues sdv = reader.getSortedNumericDocValues(query.field);
-
- while (termsEnum.next() != null) {
- docs = termsEnum.postings(docs, PostingsEnum.NONE);
- // boundary terms need post filtering by
- if (termsEnum.boundaryTerm()) {
- int docId = docs.nextDoc();
- long hash;
- do {
- sdv.setDocument(docId);
- for (int i=0; i<sdv.count(); ++i) {
- hash = sdv.valueAt(i);
- if (termsEnum.postFilter(GeoUtils.mortonUnhashLon(hash), GeoUtils.mortonUnhashLat(hash))) {
- builder.add(docId);
- break;
- }
- }
- } while ((docId = docs.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS);
- } else {
- builder.add(docs);
- }
- }
-
- return builder.build();
- }
-
- private Scorer scorer(DocIdSet set) throws IOException {
- if (set == null) {
- return null;
- }
- final DocIdSetIterator disi = set.iterator();
- if (disi == null) {
- return null;
- }
- return new ConstantScoreScorer(this, score(), disi);
- }
-
- @Override
- public BulkScorer bulkScorer(LeafReaderContext context) throws IOException {
- final Scorer scorer = scorer(getDocIDs(context));
- if (scorer == null) {
- return null;
- }
- return new DefaultBulkScorer(scorer);
- }
-
- @Override
- public Scorer scorer(LeafReaderContext context) throws IOException {
- return scorer(getDocIDs(context));
- }
- };
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermsEnum.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermsEnum.java b/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermsEnum.java
deleted file mode 100644
index 2c40f97..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/search/GeoPointTermsEnum.java
+++ /dev/null
@@ -1,249 +0,0 @@
-/*
- * 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.search;
-
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.apache.lucene.document.GeoPointField;
-import org.apache.lucene.index.FilteredTermsEnum;
-import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.util.BytesRef;
-import org.apache.lucene.util.BytesRefBuilder;
-import org.apache.lucene.util.GeoRelationUtils;
-import org.apache.lucene.util.GeoUtils;
-import org.apache.lucene.util.NumericUtils;
-
-/**
- * computes all ranges along a space-filling curve that represents
- * the given bounding box and enumerates all terms contained within those ranges
- *
- * @lucene.experimental
- */
-abstract class GeoPointTermsEnum extends FilteredTermsEnum {
- protected final double minLon;
- protected final double minLat;
- protected final double maxLon;
- protected final double maxLat;
-
- protected Range currentRange;
- private final BytesRefBuilder currentCell = new BytesRefBuilder();
- private final BytesRefBuilder nextSubRange = new BytesRefBuilder();
-
- private final List<Range> rangeBounds = new LinkedList<>();
-
- // detail level should be a factor of PRECISION_STEP limiting the depth of recursion (and number of ranges)
- protected final short DETAIL_LEVEL;
-
- GeoPointTermsEnum(final TermsEnum tenum, final double minLon, final double minLat,
- final double maxLon, final double maxLat) {
- super(tenum);
- final long rectMinHash = GeoUtils.mortonHash(minLon, minLat);
- final long rectMaxHash = GeoUtils.mortonHash(maxLon, maxLat);
- this.minLon = GeoUtils.mortonUnhashLon(rectMinHash);
- this.minLat = GeoUtils.mortonUnhashLat(rectMinHash);
- this.maxLon = GeoUtils.mortonUnhashLon(rectMaxHash);
- this.maxLat = GeoUtils.mortonUnhashLat(rectMaxHash);
- DETAIL_LEVEL = (short)(((GeoUtils.BITS<<1)-computeMaxShift())/2);
-
- computeRange(0L, (short) ((GeoUtils.BITS << 1) - 1));
- assert rangeBounds.isEmpty() == false;
- Collections.sort(rangeBounds);
- }
-
- /**
- * entry point for recursively computing ranges
- */
- private final void computeRange(long term, final short shift) {
- final long split = term | (0x1L<<shift);
- assert shift < 64;
- final long upperMax;
- if (shift < 63) {
- upperMax = term | ((1L << (shift+1))-1);
- } else {
- upperMax = 0xffffffffffffffffL;
- }
- final long lowerMax = split-1;
-
- relateAndRecurse(term, lowerMax, shift);
- relateAndRecurse(split, upperMax, shift);
- }
-
- /**
- * recurse to higher level precision cells to find ranges along the space-filling curve that fall within the
- * query box
- *
- * @param start starting value on the space-filling curve for a cell at a given res
- * @param end ending value on the space-filling curve for a cell at a given res
- * @param res spatial res represented as a bit shift (MSB is lower res)
- */
- private void relateAndRecurse(final long start, final long end, final short res) {
- final double minLon = GeoUtils.mortonUnhashLon(start);
- final double minLat = GeoUtils.mortonUnhashLat(start);
- final double maxLon = GeoUtils.mortonUnhashLon(end);
- final double maxLat = GeoUtils.mortonUnhashLat(end);
-
- final short level = (short)((GeoUtils.BITS<<1)-res>>>1);
-
- // if cell is within and a factor of the precision step, or it crosses the edge of the shape add the range
- final boolean within = res % GeoPointField.PRECISION_STEP == 0 && cellWithin(minLon, minLat, maxLon, maxLat);
- if (within || (level == DETAIL_LEVEL && cellIntersectsShape(minLon, minLat, maxLon, maxLat))) {
- final short nextRes = (short)(res-1);
- if (nextRes % GeoPointField.PRECISION_STEP == 0) {
- rangeBounds.add(new Range(start, nextRes, !within));
- rangeBounds.add(new Range(start|(1L<<nextRes), nextRes, !within));
- } else {
- rangeBounds.add(new Range(start, res, !within));
- }
- } else if (level < DETAIL_LEVEL && cellIntersectsMBR(minLon, minLat, maxLon, maxLat)) {
- computeRange(start, (short) (res - 1));
- }
- }
-
- protected short computeMaxShift() {
- // in this case a factor of 4 brings the detail level to ~0.002/0.001 degrees lon/lat respectively (or ~222m/111m)
- return GeoPointField.PRECISION_STEP * 4;
- }
-
- /**
- * Determine whether the quad-cell crosses the shape
- */
- protected abstract boolean cellCrosses(final double minLon, final double minLat, final double maxLon, final double maxLat);
-
- /**
- * Determine whether quad-cell is within the shape
- */
- protected abstract boolean cellWithin(final double minLon, final double minLat, final double maxLon, final double maxLat);
-
- /**
- * Default shape is a rectangle, so this returns the same as {@code cellIntersectsMBR}
- */
- protected abstract boolean cellIntersectsShape(final double minLon, final double minLat, final double maxLon, final double maxLat);
-
- /**
- * Primary driver for cells intersecting shape boundaries
- */
- protected boolean cellIntersectsMBR(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectIntersects(minLon, minLat, maxLon, maxLat, this.minLon, this.minLat, this.maxLon, this.maxLat);
- }
-
- /**
- * Return whether quad-cell contains the bounding box of this shape
- */
- protected boolean cellContains(final double minLon, final double minLat, final double maxLon, final double maxLat) {
- return GeoRelationUtils.rectWithin(this.minLon, this.minLat, this.maxLon, this.maxLat, minLon, minLat, maxLon, maxLat);
- }
-
- public boolean boundaryTerm() {
- if (currentRange == null) {
- throw new IllegalStateException("GeoPointTermsEnum empty or not initialized");
- }
- return currentRange.boundary;
- }
-
- private void nextRange() {
- currentRange = rangeBounds.remove(0);
- currentRange.fillBytesRef(currentCell);
- }
-
- @Override
- protected final BytesRef nextSeekTerm(BytesRef term) {
- while (!rangeBounds.isEmpty()) {
- if (currentRange == null) {
- nextRange();
- }
-
- // if the new upper bound is before the term parameter, the sub-range is never a hit
- if (term != null && term.compareTo(currentCell.get()) > 0) {
- nextRange();
- if (!rangeBounds.isEmpty()) {
- continue;
- }
- }
- // never seek backwards, so use current term if lower bound is smaller
- return (term != null && term.compareTo(currentCell.get()) > 0) ?
- term : currentCell.get();
- }
-
- // no more sub-range enums available
- assert rangeBounds.isEmpty();
- return null;
- }
-
- /**
- * The two-phase query approach. {@link #nextSeekTerm} is called to obtain the next term that matches a numeric
- * range of the bounding box. Those terms that pass the initial range filter are then compared against the
- * decoded min/max latitude and longitude values of the bounding box only if the range is not a "boundary" range
- * (e.g., a range that straddles the boundary of the bbox).
- * @param term term for candidate document
- * @return match status
- */
- @Override
- protected AcceptStatus accept(BytesRef term) {
- // validate value is in range
- while (currentCell == null || term.compareTo(currentCell.get()) > 0) {
- if (rangeBounds.isEmpty()) {
- return AcceptStatus.END;
- }
- // peek next sub-range, only seek if the current term is smaller than next lower bound
- rangeBounds.get(0).fillBytesRef(this.nextSubRange);
- if (term.compareTo(this.nextSubRange.get()) < 0) {
- return AcceptStatus.NO_AND_SEEK;
- }
- // step forward to next range without seeking, as next range is less or equal current term
- nextRange();
- }
-
- return AcceptStatus.YES;
- }
-
- protected abstract boolean postFilter(final double lon, final double lat);
-
- /**
- * Internal class to represent a range along the space filling curve
- */
- protected final class Range implements Comparable<Range> {
- final short shift;
- final long start;
- final boolean boundary;
-
- Range(final long lower, final short shift, boolean boundary) {
- this.boundary = boundary;
- this.start = lower;
- this.shift = shift;
- }
-
- /**
- * Encode as a BytesRef using a reusable object. This allows us to lazily create the BytesRef (which is
- * quite expensive), only when we need it.
- */
- private void fillBytesRef(BytesRefBuilder result) {
- assert result != null;
- NumericUtils.longToPrefixCoded(start, shift, result);
- }
-
- @Override
- public int compareTo(Range other) {
- final int result = Short.compare(this.shift, other.shift);
- if (result == 0) {
- return Long.compare(this.start, other.start);
- }
- return result;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/187fe876/lucene/sandbox/src/java/org/apache/lucene/util/GeoDistanceUtils.java
----------------------------------------------------------------------
diff --git a/lucene/sandbox/src/java/org/apache/lucene/util/GeoDistanceUtils.java b/lucene/sandbox/src/java/org/apache/lucene/util/GeoDistanceUtils.java
deleted file mode 100644
index 9134709..0000000
--- a/lucene/sandbox/src/java/org/apache/lucene/util/GeoDistanceUtils.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * 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.util;
-
-import static org.apache.lucene.util.SloppyMath.TO_RADIANS;
-
-/**
- * Reusable geo-spatial distance utility methods.
- *
- * @lucene.experimental
- */
-public class GeoDistanceUtils {
- /** error threshold for point-distance queries (in percent) NOTE: Guideline from USGS is 0.005 **/
- public static final double DISTANCE_PCT_ERR = 0.005;
-
- /**
- * Compute the great-circle distance using original haversine implementation published by Sinnot in:
- * R.W. Sinnott, "Virtues of the Haversine", Sky and Telescope, vol. 68, no. 2, 1984, p. 159
- *
- * NOTE: this differs from {@link org.apache.lucene.util.SloppyMath#haversin} in that it uses the semi-major axis
- * of the earth instead of an approximation based on the average latitude of the two points (which can introduce an
- * additional error up to .337%, or ~67.6 km at the equator)
- */
- public static double haversin(double lat1, double lon1, double lat2, double lon2) {
- double dLat = TO_RADIANS * (lat2 - lat1);
- double dLon = TO_RADIANS * (lon2 - lon1);
- lat1 = TO_RADIANS * (lat1);
- lat2 = TO_RADIANS * (lat2);
-
- final double sinDLatO2 = SloppyMath.sin(dLat / 2);
- final double sinDLonO2 = SloppyMath.sin(dLon / 2);
-
- double a = sinDLatO2*sinDLatO2 + sinDLonO2 * sinDLonO2 * SloppyMath.cos(lat1) * SloppyMath.cos(lat2);
- double c = 2 * SloppyMath.asin(Math.sqrt(a));
- return (GeoProjectionUtils.SEMIMAJOR_AXIS * c);
- }
-
- /**
- * Compute the distance between two geo-points using vincenty distance formula
- * Vincenty uses the oblate spheroid whereas haversine uses unit sphere, this will give roughly
- * 22m better accuracy (in worst case) than haversine
- *
- * @param lonA longitudinal coordinate of point A (in degrees)
- * @param latA latitudinal coordinate of point A (in degrees)
- * @param lonB longitudinal coordinate of point B (in degrees)
- * @param latB latitudinal coordinate of point B (in degrees)
- * @return distance (in meters) between point A and point B
- */
- public static final double vincentyDistance(final double lonA, final double latA, final double lonB, final double latB) {
- final double L = StrictMath.toRadians(lonB - lonA);
- final double oF = 1 - GeoProjectionUtils.FLATTENING;
- final double U1 = StrictMath.atan(oF * StrictMath.tan(StrictMath.toRadians(latA)));
- final double U2 = StrictMath.atan(oF * StrictMath.tan(StrictMath.toRadians(latB)));
- final double sU1 = StrictMath.sin(U1);
- final double cU1 = StrictMath.cos(U1);
- final double sU2 = StrictMath.sin(U2);
- final double cU2 = StrictMath.cos(U2);
-
- double sigma, sinSigma, cosSigma;
- double sinAlpha, cos2Alpha, cos2SigmaM;
- double lambda = L;
- double lambdaP;
- double iters = 100;
- double sinLambda, cosLambda, c;
-
- do {
- sinLambda = StrictMath.sin(lambda);
- cosLambda = Math.cos(lambda);
- sinSigma = Math.sqrt((cU2 * sinLambda) * (cU2 * sinLambda) + (cU1 * sU2 - sU1 * cU2 * cosLambda)
- * (cU1 * sU2 - sU1 * cU2 * cosLambda));
- if (sinSigma == 0) {
- return 0;
- }
-
- cosSigma = sU1 * sU2 + cU1 * cU2 * cosLambda;
- sigma = Math.atan2(sinSigma, cosSigma);
- sinAlpha = cU1 * cU2 * sinLambda / sinSigma;
- cos2Alpha = 1 - sinAlpha * sinAlpha;
- cos2SigmaM = cosSigma - 2 * sU1 * sU2 / cos2Alpha;
-
- c = GeoProjectionUtils.FLATTENING/16 * cos2Alpha * (4 + GeoProjectionUtils.FLATTENING * (4 - 3 * cos2Alpha));
- lambdaP = lambda;
- lambda = L + (1 - c) * GeoProjectionUtils.FLATTENING * sinAlpha * (sigma + c * sinSigma * (cos2SigmaM + c * cosSigma *
- (-1 + 2 * cos2SigmaM * cos2SigmaM)));
- } while (StrictMath.abs(lambda - lambdaP) > 1E-12 && --iters > 0);
-
- if (iters == 0) {
- return 0;
- }
-
- final double uSq = cos2Alpha * (GeoProjectionUtils.SEMIMAJOR_AXIS2 - GeoProjectionUtils.SEMIMINOR_AXIS2) / (GeoProjectionUtils.SEMIMINOR_AXIS2);
- final double A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
- final double B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
- final double deltaSigma = B * sinSigma * (cos2SigmaM + B/4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B/6 * cos2SigmaM
- * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
-
- return (GeoProjectionUtils.SEMIMINOR_AXIS * A * (sigma - deltaSigma));
- }
-
- /**
- * Computes distance between two points in a cartesian (x, y, {z - optional}) coordinate system
- */
- public static double linearDistance(double[] pt1, double[] pt2) {
- assert pt1 != null && pt2 != null && pt1.length == pt2.length && pt1.length > 1;
- final double d0 = pt1[0] - pt2[0];
- final double d1 = pt1[1] - pt2[1];
- if (pt1.length == 3) {
- final double d2 = pt1[2] - pt2[2];
- return Math.sqrt(d0*d0 + d1*d1 + d2*d2);
- }
- return Math.sqrt(d0*d0 + d1*d1);
- }
-
- /**
- * Compute the inverse haversine to determine distance in degrees longitude for provided distance in meters
- * @param lat latitude to compute delta degrees lon
- * @param distance distance in meters to convert to degrees lon
- * @return Sloppy distance in degrees longitude for provided distance in meters
- */
- public static double distanceToDegreesLon(double lat, double distance) {
- distance /= 1000.0;
- // convert latitude to radians
- lat = StrictMath.toRadians(lat);
-
- // get the diameter at the latitude
- final double diameter = SloppyMath.earthDiameter(StrictMath.toRadians(lat));
-
- // compute inverse haversine
- double a = StrictMath.sin(distance/diameter);
- double h = StrictMath.min(1, a);
- h *= h;
- double cLat = StrictMath.cos(lat);
-
- return StrictMath.toDegrees(StrictMath.acos(1-((2d*h)/(cLat*cLat))));
- }
-
- /**
- * Finds the closest point within a rectangle (defined by rMinX, rMinY, rMaxX, rMaxY) to the given (lon, lat) point
- * the result is provided in closestPt. When the point is outside the rectangle, the closest point is on an edge
- * or corner of the rectangle; else, the closest point is the point itself.
- */
- public static void closestPointOnBBox(final double rMinX, final double rMinY, final double rMaxX, final double rMaxY,
- final double lon, final double lat, double[] closestPt) {
- assert closestPt != null && closestPt.length == 2;
-
- closestPt[0] = 0;
- closestPt[1] = 0;
-
- boolean xSet = true;
- boolean ySet = true;
-
- if (lon > rMaxX) {
- closestPt[0] = rMaxX;
- } else if (lon < rMinX) {
- closestPt[0] = rMinX;
- } else {
- xSet = false;
- }
-
- if (lat > rMaxY) {
- closestPt[1] = rMaxY;
- } else if (lat < rMinY) {
- closestPt[1] = rMinY;
- } else {
- ySet = false;
- }
-
- if (closestPt[0] == 0 && xSet == false) {
- closestPt[0] = lon;
- }
-
- if (closestPt[1] == 0 && ySet == false) {
- closestPt[1] = lat;
- }
- }
-
- /** Returns the maximum distance/radius (in meters) from the point 'center' before overlapping */
- public static double maxRadialDistanceMeters(final double centerLon, final double centerLat) {
- if (Math.abs(centerLat) == GeoUtils.MAX_LAT_INCL) {
- return GeoDistanceUtils.haversin(centerLat, centerLon, 0, centerLon);
- }
- return GeoDistanceUtils.haversin(centerLat, centerLon, centerLat, (GeoUtils.MAX_LON_INCL + centerLon) % 360);
- }
-
- /**
- * Compute the inverse haversine to determine distance in degrees longitude for provided distance in meters
- * @param lat latitude to compute delta degrees lon
- * @param distance distance in meters to convert to degrees lon
- * @return Sloppy distance in degrees longitude for provided distance in meters
- */
- public static double distanceToDegreesLat(double lat, double distance) {
- // get the diameter at the latitude
- final double diameter = SloppyMath.earthDiameter(StrictMath.toRadians(lat));
- distance /= 1000.0;
-
- // compute inverse haversine
- double a = StrictMath.sin(distance/diameter);
- double h = StrictMath.min(1, a);
- h *= h;
-
- return StrictMath.toDegrees(StrictMath.acos(1-(2d*h)));
- }
-}