Implement maptile geo grid hashing

Add support for map aggregation based on a very common
"tile" pattern - given a zoom level, hashes are computed
in the same way as tile indexes (zoom/x/y)

Author: nyurik

server/src/main/java/org/elasticsearch/common/geo/GeoHashUtils.java

@@ -25,6 +25,9 @@
 import java.util.ArrayList;
 import java.util.Collection;
 
+import static org.elasticsearch.common.geo.GeoUtils.normalizeLat;
+import static org.elasticsearch.common.geo.GeoUtils.normalizeLon;
+
 /**
  * Utilities for converting to/from the GeoHash standard
  *
@@ -351,4 +354,83 @@ public static final double decodeLatitude(final String geohash) {
     public static final double decodeLongitude(final String geohash) {
         return decodeLongitude(mortonEncode(geohash));
     }
+
+
+    /* ****** Converting geopoint to Spherical Mercator as tiles ****** */
+
+    public static final int MAX_ZOOM = 26;
+
+    /**
+     * Convert [longitude, latitude] to a hash tha combines zoom, x, and y of the tile.
+     */
+    public static long geoToMapTileHash(final double longitude, final double latitude, final int zoom) {
+        // Adapted from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Java
+
+        if (zoom < 0 || zoom > MAX_ZOOM) {
+            throw new IllegalArgumentException("zoom");
+        }
+        // How many tiles in X and in Y
+        final int tiles = 1 << zoom;
+        final double lon = normalizeLon(longitude);
+        final double lat = normalizeLat(latitude);
+
+        int xtile = (int) Math.floor((lon + 180) / 360 * tiles);
+        int ytile = (int) Math.floor(
+            (1 - Math.log(
+                Math.tan(Math.toRadians(lat)) + 1 / Math.cos(Math.toRadians(lat))
+            ) / Math.PI) / 2 * tiles);
+        if (xtile < 0)
+            xtile = 0;
+        if (xtile >= tiles)
+            xtile = (tiles - 1);
+        if (ytile < 0)
+            ytile = 0;
+        if (ytile >= tiles)
+            ytile = (tiles - 1);
+
+        // with max zoom being 26, the largest index would be 2^52 (51st..0th),
+        // leaving 12 bits unused. Zoom cannot be >26, so it can fit into 5 bits (56th..52nd)
+        return BitUtil.interleave(xtile, ytile) | ((long) zoom << 52);
+    }
+
+    private static int[] parseMapTileHash(final long hash) {
+        int zoom = (int) (hash >> 52);
+        if (zoom < 0 || zoom > MAX_ZOOM) {
+            throw new IllegalArgumentException("hash-zoom");
+        }
+
+        final int tiles = 1 << zoom;
+        // decode last 52 bits as xtile and ytile
+        long val = hash & 0x000FFFFFFFFFFFFFL;
+        int xtile = (int) BitUtil.deinterleave(val);
+        int ytile = (int) BitUtil.deinterleave(val >> 1);
+        if (xtile < 0 || ytile < 0 || xtile >= tiles || ytile >= tiles) {
+            throw new IllegalArgumentException("hash-tile");
+        }
+
+        return new int[]{zoom, xtile, ytile};
+    }
+
+    public static String geoTileMapHashToKey(final long geohashAsLong) {
+        int[] res = parseMapTileHash(geohashAsLong);
+        return "" + res[0] + "/" + res[1] + "/" + res[2];
+    }
+
+    private static double tile2lon(final int x, final double tiles) {
+        return x / tiles * 360.0 - 180;
+    }
+
+    private static double tile2lat(final int y, final double tiles) {
+        double n = Math.PI - (2.0 * Math.PI * y) / tiles;
+        return Math.toDegrees(Math.atan(Math.sinh(n)));
+    }
+
+    public static Rectangle bboxFromTileIndex(long geohashAsLong) {
+        int[] res = parseMapTileHash(geohashAsLong);
+        int zoom = res[0], x = res[1], y = res[2];
+        double tiles = Math.pow(2.0, zoom); // optimization
+
+        return new Rectangle(tile2lat(y, tiles), tile2lat(y + 1, tiles),
+            tile2lon(x, tiles), tile2lon(x + 1, tiles));
+    }
 }

server/src/main/java/org/elasticsearch/common/geo/GeoUtils.java

@@ -544,6 +544,12 @@ public static int checkPrecisionRange(int precision, GeoHashType type) {
             case pluscode:
                 PluscodeHash.validatePrecision(precision);
                 break;
+            case maptile:
+                if (precision < 0 || precision > GeoHashUtils.MAX_ZOOM) {
+                    throw new IllegalArgumentException("Invalid geohash maptile aggregation precision of " + precision +
+                        ". Must be between 0 and " + GeoHashUtils.MAX_ZOOM + ".");
+                }
+                break;
             default:
                 throw new IllegalArgumentException("Unknown type " + type.toString());
         }

server/src/main/java/org/elasticsearch/search/aggregations/bucket/geogrid/GeoGridAggregationBuilder.java

@@ -257,6 +257,9 @@ public boolean advanceExact(int docId) throws IOException {
                         case pluscode:
                             values[i] = PluscodeHash.latLngToPluscodeHash(target.getLon(), target.getLat(), precision);
                             break;
+                        case maptile:
+                            values[i] = GeoHashUtils.geoToMapTileHash(target.getLon(), target.getLat(), precision);
+                            break;
                         default:
                             throw new IllegalArgumentException();
                     }

server/src/main/java/org/elasticsearch/search/aggregations/bucket/geogrid/GeoHashType.java

@@ -22,4 +22,5 @@
 public enum GeoHashType {
     geohash,
     pluscode,
+    maptile,
 }

server/src/main/java/org/elasticsearch/search/aggregations/bucket/geogrid/InternalGeoHashGrid.java

@@ -87,6 +87,8 @@ public String getKeyAsString() {
                     return GeoHashUtils.stringEncode(geohashAsLong);
                 case pluscode:
                     return PluscodeHash.decodePluscode(geohashAsLong);
+                case maptile:
+                    return GeoHashUtils.geoTileMapHashToKey(geohashAsLong);
                 default:
                     throw new IllegalArgumentException();
             }
@@ -99,6 +101,8 @@ public Object getKey() {
                     return GeoPoint.fromGeohash(geohashAsLong);
                 case pluscode:
                     return PluscodeHash.bboxFromPluscode(geohashAsLong);
+                case maptile:
+                    return GeoHashUtils.bboxFromTileIndex(geohashAsLong);
                 default:
                     throw new IllegalArgumentException();
             }