import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
/**
    * To get the range.
    * @param center
    * @param radius
    * @return LnikedList<> {lowk,uppk}
    */
   private static LinkedList<double[]> rangeOnSameRoute(Location center,double radius){
WGS84Point WGS84center = new WGS84Point(center.getLatitude(),center.getLongitude());
WGS84Point WGS84NorthEast = VincentyGeodesy.moveInDirection(VincentyGeodesy.moveInDirection(WGS84center, 0, radius), 90,radius);
WGS84Point WGS84SouthWest = VincentyGeodesy.moveInDirection(VincentyGeodesy.moveInDirection(WGS84center, 180, radius),270, radius);

double[] uppk = {Integer.MAX_VALUE,
		Integer.MAX_VALUE,
		Integer.MAX_VALUE,
		WGS84NorthEast.getLongitude(),
		WGS84NorthEast.getLatitude()};

double[] lowk = {0,
		0,
		0,
		WGS84SouthWest.getLongitude(),
		WGS84SouthWest.getLatitude()};

LinkedList<double[]> range = new LinkedList<double[]>();
range.add(lowk);
range.add(uppk);
return range;
   }
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Override
public Object apply(List<Object> args, Context context) throws ParseException {
  if(args.size() < 1) {
    return null;
  }
  String hash = (String)args.get(0);
  if(hash == null) {
    return null;
  }

  Optional<WGS84Point> point = GeoHashUtil.INSTANCE.toPoint(hash);
  if(point.isPresent()) {
    Map<String, Object> ret = new HashMap<>();
    ret.put(GeoLiteDatabase.GeoProps.LONGITUDE.getSimpleName(), point.get().getLongitude());
    ret.put(GeoLiteDatabase.GeoProps.LATITUDE.getSimpleName(), point.get().getLatitude());
    return ret;
  }
  return null;
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Override
public boolean filterRowKey(
        final byte[] buffer,
        final int offset,
        final int length)
{
    boolean filter;
    final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buffer, offset, length);
    final DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream);
    try
    {
        final long bits = dataInputStream.readLong();
        final double lon = dataInputStream.readDouble();
        final double lat = dataInputStream.readDouble();
        filter = !m_boundingBox.contains(new WGS84Point(lat, lon));
    }
    catch (IOException e)
    {
        filter = true;
    }
    return filter;
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
/**
 * Calculate the geo hash cells we need to query in order to cover all points within this query
 *
 * @return
 */
private Set<String> getSearchHashes() {
    GeoHashCircleQuery q = new GeoHashCircleQuery(new WGS84Point(lat, lon), radius);

    // Since the circle query doesn't have pre-defined precision, we need to calculate all the
    // relevant geohashes in our precision manually
    GeoHash center = GeoHash.withCharacterPrecision(lat, lon, precision);

    Set<String> hashKeys = new HashSet<>(8);
    Set<GeoHash> seen = new HashSet<>(8);
    Queue<GeoHash> candidates = new LinkedList<>();

    candidates.add(center);

    while (!candidates.isEmpty()) {
        GeoHash gh = candidates.remove();
        hashKeys.add(geoKey(gh.toBase32()));

        GeoHash[] neighbors = gh.getAdjacent();
        for (GeoHash neighbor : neighbors) {
            if (seen.add(neighbor) && q.contains(neighbor)) {
                candidates.add(neighbor);
            }
        }

    }
    return hashKeys;
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Test
void apply() {
	final double longitude = 10.0;
	final double latitude = 20.0;
	final Coordinate coordinate = new WGS84Point2Coordinate().apply(new WGS84Point(latitude, longitude));
	assertEquals(longitude, coordinate.x);
	assertEquals(latitude, coordinate.y);
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Test
void discretize() {
	final Coordinate coordinate1 = this.wgs84Point2Coordinate.apply(new WGS84Point(10.0, 10.0));
	final Coordinate coordinate2 = this.wgs84Point2Coordinate.apply(new WGS84Point(45.0, 10.0));
	final LineString lineString = new GeometryFactory().createLineString(
			new Coordinate[]{coordinate1, coordinate2});
	final Set<GeoHash> geoHashes = this.segmentDiscretizer.apply(lineString, 2);
	assertEquals(8, geoHashes.size());
	final Set<GeoHash> expected = of("s1", "s4", "s5", "sh", "sj", "sn", "sp", "u0").map(GeoHash::fromGeohashString)
			.collect(toSet());
	assertEquals(expected, geoHashes);
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Test
void apply() {
	final double longitude = 10.0;
	final double latitude = 20.0;
	final WGS84Point point = new Coordinate2WGS84Point().apply(new Coordinate(longitude, latitude));
	assertEquals(longitude, point.getLongitude());
	assertEquals(latitude, point.getLatitude());
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Test
public void testEncodeDecode() throws Exception
{
    for (int i = 0; i < 100; i++)
    {
        final double lon = -180 + 360 * Math.random();
        final double lat = -90 + 180 * Math.random();
        final WGS84Point point = Quad.decode(Quad.encode(lon, lat)).getCenterPoint();
        assertEquals(lat, point.getLatitude(), 0.000001);
        assertEquals(lon, point.getLongitude(), 0.000001);
    }
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
private void scanBox(final HTableInterface table) throws IOException
{
    final List<WGS84Point> list = new ArrayList<WGS84Point>();
    final BoundingBox boundingBox = new BoundingBox(0.5, 1.5, 0.5, 1.5);
    final GeoHashBoundingBoxQuery geoHashBoundingBoxQuery = new GeoHashBoundingBoxQuery(boundingBox);
    final List<GeoHash> searchHashes = geoHashBoundingBoxQuery.getSearchHashes();
    for (final GeoHash geoHash : searchHashes)
    {
        scanGeoHash(table, geoHash, boundingBox, list);
    }
    Assert.assertEquals(1, list.size());
    final WGS84Point point = list.get(0);
    Assert.assertEquals(1.0, point.getLatitude(), 0.000001);
    Assert.assertEquals(1.0, point.getLongitude(), 0.000001);
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
private void scanGeoHash(
        final HTableInterface table,
        final GeoHash geoHash,
        final BoundingBox boundingBox,
        final List<WGS84Point> list) throws IOException
{
    final Scan scan = new Scan();
    scan.setStartRow(Bytes.toBytes(geoHash.longValue()));
    scan.setStopRow(Bytes.toBytes(geoHash.next().longValue()));
    scan.setMaxVersions(1);
    scan.setCaching(50);
    scan.setFilter(new BoundingBoxFilter(boundingBox));
    final ResultScanner scanner = table.getScanner(scan);
    try
    {
        for (final Result result : scanner)
        {
            final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(result.getRow());
            final DataInput dataInput = new DataInputStream(byteArrayInputStream);
            final long bits = dataInput.readLong();
            final double lon = dataInput.readDouble();
            final double lat = dataInput.readDouble();
            list.add(new WGS84Point(lat, lon));
        }
    }
    finally
    {
        scanner.close();
    }
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
public static boolean nearNYC(double latitude, double longitude) {
  return NYC.stream().anyMatch(hash -> hash.contains(new WGS84Point(latitude, longitude)));
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
public static boolean nearJFK(double latitude, double longitude) {
  return JFK.stream().anyMatch(hash -> hash.contains(new WGS84Point(latitude, longitude)));
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
public static boolean nearLGA(double latitude, double longitude) {
  return LGA.stream().anyMatch(hash -> hash.contains(new WGS84Point(latitude, longitude)));
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
private Function<WGS84Point, Coordinate> wgs84Point2Coordinate() {
	return new WGS84Point2Coordinate();
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
private Function<Coordinate, WGS84Point> coordinate2WGS84Point() {
	return new Coordinate2WGS84Point();
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Override
public Coordinate apply(@NonNull WGS84Point wgs84Point) {
	return new Coordinate(wgs84Point.getLongitude(), wgs84Point.getLatitude());
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
public GeoHash apply(@NonNull Coordinate coordinate, @NonNull Integer precision) {
	final WGS84Point point = this.coordinate2WGS84Point.apply(coordinate);
	return GeoHash.withCharacterPrecision(point.getLatitude(), point.getLongitude(), precision);
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
@Override
public WGS84Point apply(@NonNull Coordinate coordinate) {
	return new WGS84Point(coordinate.y, coordinate.x);
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
protected Coordinate c1() {
	return coordinate(new WGS84Point(46.760796734739515, 23.62060546875));
}
 

import ch.hsr.geohash.WGS84Point; //导入依赖的package包/类
private Coordinate c2() {
	return coordinate(new WGS84Point(47.0160778535083, 21.8408203125));
}