本文整理汇总了Java中ch.hsr.geohash.GeoHash类的典型用法代码示例。如果您正苦于以下问题:Java GeoHash类的具体用法?Java GeoHash怎么用?Java GeoHash使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
GeoHash类属于ch.hsr.geohash包,在下文中一共展示了GeoHash类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: apply
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());
}
示例2: apply
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;
}
示例3: printDebugWKT
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));
}
示例4: queryKNN
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;
}
示例5: minimumBoundingPrefixes
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");
}
示例6: onLoadFinished
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);
}
});
}
示例7: search
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;
}
示例8: getSearchHashes
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;
}
示例9: encode
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;
}
示例10: intersectedGeoHashes
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));
}
示例11: apply
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());
}
示例12: apply
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();
}
示例13: apply
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));
}
示例14: discretize
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);
}
示例15: discretized123456
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());
}