import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public Set<GeoHash> apply(@NonNull LineString geometry, @NonNull Integer precision) {
	final Coordinate[] coordinates = geometry.getCoordinates();
	if (coordinates.length < 2) {
		throw new IllegalArgumentException();
	}

	return range(1, coordinates.length).mapToObj(
			index -> {
				final Coordinate start = coordinates[index - 1];
				final Coordinate end = coordinates[index];
				final LineString segment = geometry.getFactory().createLineString(new Coordinate[]{start, end});
				return this.segmentDiscretizer.apply(segment, precision);
			})
			.flatMap(Set::stream)
			.collect(toSet());
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public Set<GeoHash> apply(@NonNull LineString segment, @NonNull Integer precision) {
	if (segment.getNumPoints() != 2) {
		throw new IllegalArgumentException();
	}
	final GeoHash destination = this.coordinateDiscretizer.apply(segment.getCoordinateN(1), precision);
	final Set<GeoHash> accumulator = new HashSet<>();
	Set<GeoHash> seed = Stream.of(this.coordinateDiscretizer.apply(segment.getCoordinateN(0), precision))
			.collect(toSet());
	while (!accumulator.contains(destination)) {
		accumulator.addAll(seed);
		seed = seed.stream()
				.flatMap(geoHash -> Stream.of(geoHash.getAdjacent()))
				.distinct()
				.filter(geoHash -> this.geoHash2Geometry.apply(geoHash, segment.getFactory())
						.intersects(segment))
				.collect(toSet());
	}
	return accumulator;
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
protected void printDebugWKT(Set<GeoHash> geoHashes) {
	final Set<Polygon> geometries = geoHashes
			.stream()
			.map(geoHash -> (Polygon) new GeoHash2Geometry(new WGS84Point2Coordinate()).apply(
					geoHash, new GeometryFactory()))
			.collect(toSet());
	System.out.println(geoHashes.stream()
			.map(GeoHash::toBase32)
			.map(hash -> "\"" + hash + "\"")
			.collect(toSet()));
	final Polygon[] polygons = geometries.toArray(new Polygon[geometries.size()]);
	final MultiPolygon multiPolygon = new GeometryFactory().createMultiPolygon(polygons);

	final WKTWriter wktWriter = new WKTWriter();
	System.out.println(wktWriter.write(multiPolygon));
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
public Queue<QueryMatch> queryKNN(double lat, double lon, int n)
  throws IOException {
  DistanceComparator comp = new DistanceComparator(lon, lat);
  Queue<QueryMatch> ret
    = MinMaxPriorityQueue.orderedBy(comp)
    .maximumSize(n)
    .create();

  GeoHash target = GeoHash.withCharacterPrecision(lat, lon, precision);
  ret.addAll(takeN(comp, target.toBase32(), n));
  for (GeoHash h : target.getAdjacent()) {
    ret.addAll(takeN(comp, h.toBase32(), n));
  }

  return ret;
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
GeoHash[] minimumBoundingPrefixes(Geometry query) {
  GeoHash candidate;
  Geometry candidateGeom;
  Point queryCenter = query.getCentroid();
  for (int precision = 7; precision > 0; precision--) {
    candidate
      = GeoHash.withCharacterPrecision(queryCenter.getY(),
      		                         queryCenter.getX(),
      		                         precision);

    candidateGeom = convexHull(new GeoHash[]{ candidate });
    if (candidateGeom.contains(query)) {
      return new GeoHash[]{ candidate };
    }

    candidateGeom = convexHull(candidate.getAdjacent());
    if (candidateGeom.contains(query)) {
      GeoHash[] ret = Arrays.copyOf(candidate.getAdjacent(), 9);
      ret[8] = candidate;
      return ret;
    }
  }
  throw new IllegalArgumentException(
    "Geometry cannot be contained by GeoHashs");
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public void onLoadFinished(Loader<Cursor> l, final Cursor cursor) {
    Log.d(TAG, "load finished: " + cursor.getCount());
    map.clear();
    if (cursor.getCount() == 0) return;
    cursor.moveToPosition(-1);
    while (cursor.moveToNext()) {
        GeoHash latlng = GeoHash.fromGeohashString(cursor.getString(6));
        map.addBaobab(latlng,
                cursor.getString(7),  // id
                cursor.getString(1),  // name
                cursor.getString(5)); // street
    }
    cursor.registerContentObserver(new ContentObserver(null) {

        @Override
        public void onChange(boolean selfChange) {
            getSupportLoaderManager().restartLoader(0, null, MapActivity.this);
            cursor.unregisterContentObserver(this);
        }
    });
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public boolean search(
        final double lon,
        final double lat,
        final List<ColumnInterface> columnList) throws IOException
{
    resetColumns(columnList);

    // Dummy implementation - should use buffer and then get envelope
    final BoundingBox boundingBox = new BoundingBox(
            Math.max(-90, lat - m_buffer),
            Math.min(90, lat + m_buffer),
            Math.max(-180, lon - m_buffer),
            Math.min(180, lon + m_buffer));

    final GeoHashBoundingBoxQuery geoHashBoundingBoxQuery = new GeoHashBoundingBoxQuery(boundingBox);
    final List<GeoHash> searchHashes = geoHashBoundingBoxQuery.getSearchHashes();
    for (final GeoHash geoHash : searchHashes)
    {
        doScan(geoHash, lon, lat, boundingBox, columnList);
    }
    return m_found;
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的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.GeoHash; //导入依赖的package包/类
@Override
public List<byte[]> encode(Double[] latlon) {
    ArrayList<byte[]> ret = new ArrayList<>(1);
    try {
        GeoHash h = GeoHash.withCharacterPrecision(latlon[0], latlon[1], precision);
        ret.add(h.toBase32().getBytes());
    }
    catch (IllegalArgumentException e) {
        e.printStackTrace();
    }

    return ret;

}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
public Stream<GeoHash> intersectedGeoHashes(Stream<GeoHash> currentLevel, int levelsToExplore, Polygon polygon) {
	if (levelsToExplore == 0) {
		return currentLevel;
	}
	final Set<GeoHash> offspring = currentLevel
			.flatMap(this.geoHash2ChildrenStream)
			.filter(geoHash -> polygonIntersectsGeoHash(polygon, geoHash))
			.collect(toSet());

	final Set<GeoHash> covered = offspring.stream()
			.filter(geoHash -> polygonCoversGeoHash(polygon, geoHash)).collect(toSet());

	final Stream<GeoHash> newSeed = offspring.stream().filter(geoHash -> !covered.contains(geoHash));
	return concat(covered.stream(), intersectedGeoHashes(newSeed, levelsToExplore - 1, polygon));
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public Set<GeoHash> apply(@NonNull GeometryCollection geometryCollection, @NonNull Integer precision) {
	return range(0, geometryCollection.getNumGeometries())
			.mapToObj(index -> {
				final Geometry geometry = geometryCollection.getGeometryN(index);
				return this.discretizerFactory.discretizer(geometry).apply(geometry, precision);
			})
			.flatMap(Set::stream)
			.collect(toSet());
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public Geometry apply(@NonNull GeoHash geoHash, @NonNull GeometryFactory geometryFactory) {
	final BoundingBox boundingBox = geoHash.getBoundingBox();
	final Coordinate upperLeft = this.WGS84Point2coordinate.apply(boundingBox.getUpperLeft());
	final Coordinate lowerRight = this.WGS84Point2coordinate.apply(boundingBox.getLowerRight());
	final MultiPoint multiPoint = geometryFactory.createMultiPoint(new Coordinate[]{upperLeft, lowerRight});
	return multiPoint.getEnvelope();
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Override
public Stream<GeoHash> apply(@NonNull GeoHash geoHash) {
	if (geoHash.getCharacterPrecision() == 12) {
		throw new IllegalArgumentException();
	}
	final int shift = 64 - geoHash.significantBits() - 5;
	final long base = geoHash.longValue() >> shift;
	return range(0, 32).mapToObj(index -> (base + index) << shift)
			.map(child -> fromLongValue(child, geoHash.significantBits() + 5));
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Test
void discretize() {
	final Coordinate coordinate = mock(Coordinate.class);
	final Point point = mock(Point.class);
	when(point.getCoordinate()).thenReturn(coordinate);
	final CoordinateDiscretizer coordinateDiscretizer = mock(CoordinateDiscretizer.class);
	final GeoHash geoHash = GeoHash.fromGeohashString("u33");
	when(coordinateDiscretizer.apply(coordinate, 3)).thenReturn(geoHash);
	final Set<GeoHash> geoHashes = new PointDiscretizer(coordinateDiscretizer).apply(point, 3);
	assertEquals(1, geoHashes.size());
	assertEquals(Stream.of(geoHash)
			.collect(toSet()), geoHashes);
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
protected Set<GeoHash> discretized123456() {
	return Stream.of("u2rf", "u2rg", "u82d", "u2rm", "u82f", "u2rk", "u2rp", "u2rq", "u2qp",
			"u2rn", "u2qn",
			"u2w8", "u2rs", "u2qr", "u2qx", "u824", "u2mw", "u826", "u2wb", "u2qz", "u2my", "u2re")
			.map(GeoHash::fromGeohashString)
			.collect(toSet());
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Test
void discretizeCluj() throws ParseException {
	final Polygon cluj = polygonCluj();
	final Set<GeoHash> geoHashes = this.discretizer.apply(cluj, 5);
	final Set<GeoHash> expected = discretizedPolygonCluj5()
			.map(GeoHash::fromGeohashString)
			.collect(toSet());
	assertEquals(expected, geoHashes);
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Test
void discretize() throws ParseException {
	final LineString lineString = lineString123456();
	final Set<GeoHash> geoHashes = this.discretizer.apply(lineString, 4);
	//printDebugWKT(lineString, geoHashes);

	final Set<GeoHash> expected = discretized123456();

	assertEquals(expected, geoHashes);
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Test
void discretize() {
	final MultiLineString multiLineString = this.geometryFactory.createMultiLineString(
			new LineString[]{lineString1234(), lineString456()});
	final Set<GeoHash> actual = this.discretizer.apply(multiLineString, 4);
	assertEquals(discretized123456(), actual);
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的package包/类
@Test
void applyNull() {
	assertThrows(IllegalArgumentException.class,
			() -> this.geoHash2Geometry.apply(null, mock(GeometryFactory.class)));
	assertThrows(IllegalArgumentException.class,
			() -> this.geoHash2Geometry.apply(GeoHash.fromGeohashString("s"), null));
}
 

import ch.hsr.geohash.GeoHash; //导入依赖的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);
}