def query_database_hash(hsh):
hsh = hsh[:5]
exact_matches5 = []
if hsh in _dbase:
exact_matches5 = _dbase[hsh]
r = geohash.neighbors(hsh)
neighbors5 = []
for x in r:
if x in _dbase:
neighbors5.extend(_dbase[x])
hsh = hsh[:4]
exact_matches4 = []
if hsh in _dbase:
exact_matches4 = _dbase[hsh]
r = geohash.neighbors(hsh)
neighbors4 = []
for x in r:
if x in _dbase:
neighbors4.extend(_dbase[x])
hsh = hsh[:3]
exact_matches3 = []
if hsh in _dbase:
exact_matches3 = _dbase[hsh]
r = geohash.neighbors(hsh)
neighbors3 = []
for x in r:
if x in _dbase:
neighbors3.extend(_dbase[x])
return [exact_matches5, neighbors5, exact_matches4, neighbors4, exact_matches3, neighbors3]
def nearby():
print 'geohash.bounding box'
print geohash.bbox('tdr1w')
print 'geohash neighbours'
print geohash.neighbors('tdr1wxype953')
print 'geohash expand'
print geohash.expand('tdr1wxype953')
def nearby():
print 'geohash.bounding box'
print geohash.bbox('tdr1w')
print 'geohash neighbours'
print geohash.neighbors('tdr1wxype953')
print 'geohash expand'
print geohash.expand('tdr1wxype953')
def test_one(self):
self.assertEqual(set(['1', '2', '3', 'p', 'r']),
set(geohash.neighbors("0")))
self.assertEqual(set(['w', 'x', 'y', '8', 'b']),
set(geohash.neighbors("z")))
self.assertEqual(set(['2', '6', '1', '0', '4', '9', '8', 'd']),
set(geohash.neighbors("3")))
def get_cells_in_circle(lat, lon, radius, precision):
"""Gets all geohash cells inside a circle, sorted approximately by distance.
Args:
lat: float, the latitude of the circle center.
lon: float, the longitude of the circle center.
radius: float, the radius of the circle in meters.
precision: int, the precision of the geohash.
Returns:
list, the list of geohash cells.
"""
# Get all cells that are in the circle (with the max_resolution).
# Start from the center cell.
cur_set = set([geohash.encode(lat, lon, precision)])
all_set = set(cur_set)
result = list(cur_set)
while cur_set:
# Gradually extend the found cells (all_set) layer by layer.
new_set = set([])
for cell in cur_set:
for one_neighbor in geohash.neighbors(cell):
if one_neighbor in all_set:
continue
(nb_lat, nb_lon) = geohash.decode(one_neighbor)
if distance(nb_lat, nb_lon, lat, lon) < radius:
new_set.add(one_neighbor)
all_set.update(new_set)
result.extend(list(new_set))
cur_set = new_set
return result
def solve_xmin(pt1,pt2,size):
positiondict = {'neg':[4,6,2,5,0,1],'pos':[3,7,2,5,0,1],'vert':[2,5],'zero':[0,1]}
ghash = geohash.encode(pt1[1],pt1[0],size)
# getting neighbors
neighbors = geohash.neighbors(ghash)
# setting up variables for slope determination
y1,y2,y3,y4,xmin = get_corner_points(neighbors)
# getting slope
slope = get_slope(pt1,pt2)
y = interpol_point(xmin,slope,pt1)
if y < y1 and y > y2:
slope = 'neg'
tang = 'pos'
elif y < y2 and y > y3:
slope = 'zero'
tang = 'vert'
elif y < y3 and y > y4:
slope = 'pos'
tang = 'neg'
elif y >= y1 or y <= y4:
slope = 'vert'
tang = 'zero'
if tang == 'pos' or tang == 'neg':
pos1,pos2,pos3,pos4,pos5,pos6 = positiondict[tang]
return [pos1,pos2,pos3,pos4,pos5,pos6]
pos1,pos2 = positiondict[tang]
return [pos1,pos2]
def get_moving_time(geohash1, geohash2):
try:
if geohash1 == None or geohash2 == None: # 바로 나오는 경우, 들어가는 경우
return 0
if geohash1 == '' or geohash2 == '': # 모를 경우에는 1시간을 줌
return 60
geohash1_parent = geohash1[:5]
geohash2_parent = geohash2[:5]
expanded = geohash.expand(geohash1_parent)
expanded_depth2 = set()
for gh in expanded:
neighbors = geohash.neighbors(gh)
expanded_depth2 = expanded_depth2.union(neighbors)
expanded_depth2 = list(expanded_depth2)
if geohash1 == geohash2:
return 30
elif geohash2_parent in expanded:
return 60
elif geohash2_parent in expanded_depth2:
return 90
else:
return 120
except Exception, e:
print_err_detail(e)
return 60
def filterFromSignature(data,hmap,maxDistance=5,heatThreshold=.01):
ndata = copy.deepcopy(data)
geohashlength = hmap['geohashlength']
for l in range(len(data)):
h = geohash.encode(data[l]['lat'],data[l]['lon'],geohashlength)
visited = set([h])
neighbors = set([h])
nonZeroNeighbors = [h] if (h in hmap and hmap[h]>heatThreshold) else []
d=0
while (len(nonZeroNeighbors)==0 and d<maxDistance):
nneighbors = set([])
for n in neighbors:
nneighbors.union([h for h in geohash.neighbors(n) if h not in visited])
neighbors = nneighbors
for n in neighbors:
if (n in hmap and hmap[n]>heatThreshold):
nonZeroNeighbors.append(n)
visited.union(neighbors)
d+=1
if len(nonZeroNeighbors)>0:
if len(nonZeroNeighbors)>1:
print h,nonZeroNeighbors
lat,lon=0.,0.
for n in nonZeroNeighbors:
dlat,dlon = geohash.decode(n)
lat += dlat
lon += dlon
ndata[l]= Location(lat/len(nonZeroNeighbors),
lon/len(nonZeroNeighbors),
data[l].timestamp)
return ndata
def do_geohashtogeojson(self, geoh):
"""Build GeoJSON corresponding to geohash given as parameter.
GEOHASHTOGEOJSON u09vej04 [NEIGHBORS 0]"""
geoh, with_neighbors = self._match_option('NEIGHBORS', geoh)
bbox = geohash.bbox(geoh)
north = bbox['n']
south = bbox['s']
east = bbox['e']
west = bbox['w']
if with_neighbors != '0':
neighbors = geohash.neighbors(geoh)
for neighbor in neighbors:
bbox = geohash.bbox(neighbor)
if bbox['n'] > north:
north = bbox['n']
if bbox['s'] < south:
south = bbox['s']
if bbox['e'] > east:
east = bbox['e']
if bbox['w'] < west:
west = bbox['w']
geojson = {
"type": "Polygon",
"coordinates": [[
[west, north],
[east, north],
[east, south],
[west, south],
[west, north]
]]
}
print(white(json.dumps(geojson)))
def get_sites_near_latlon(self, lat, lon):
ghash = geohash.encode(float(lat), float(lon))
hashes = geohash.neighbors(ghash)
hashes.append(ghash)
sites = rds.zrange(sitekey, 0, -1, withscores = True)
hashmatches = {}
for chars in range(6,3,-1):
for sitehash, id in sites:
for currenthash in hashes:
if currenthash[0:chars] == sitehash[0:chars]:
hashmatches[sitehash] = int(id)
if len(hashmatches) > 0:
break
sites = []
if len(hashmatches) > 0:
for hash, id in hashmatches.items():
site = self.fetch_id(id)
if site:
sites.append(site)
return sites
def _buil_cell_tiles_from_bbox(self, bbox_coordinates):
'''Computes all geohash tile in the given bounding box
:param bbox_coordinates: the bounding box coordinates of the geohashes
:return: a list of geohashes
'''
checked_geohashes = set()
geohash_stack = set()
geohashes = []
'''get center of bounding box, assuming the earth is flat'''
center_longitude = (bbox_coordinates[0] + bbox_coordinates[2]) / 2
center_latitude = (bbox_coordinates[1] + bbox_coordinates[3]) / 2
center_geohash = self.build_cell([center_longitude, center_latitude])
geohashes.append(center_geohash)
geohash_stack.add(center_geohash)
checked_geohashes.add(center_geohash)
while len(geohash_stack) > 0:
current_geohash = geohash_stack.pop()
neighbors = geohash.neighbors(current_geohash)
for neighbor in neighbors:
if neighbor not in checked_geohashes and self._is_geohash_in_bounding_box(neighbor, bbox_coordinates):
geohashes.append(neighbor)
geohash_stack.add(neighbor)
checked_geohashes.add(neighbor)
geohashes.sort()
return geohashes
def compute_geohash_tiles(bbox_coordinates):
"""Computes all geohash tile in the given bounding box
:param bbox_coordinates: the bounding box coordinates of the geohashes
:return: a list of geohashes
"""
checked_geohashes = set()
geohash_stack = set()
geohashes = []
# get center of bounding box, assuming the earth is flat ;)
center_latitude = (bbox_coordinates[0] + bbox_coordinates[2]) / 2
center_longitude = (bbox_coordinates[1] + bbox_coordinates[3]) / 2
center_geohash = geohash.encode(center_latitude,
center_longitude,
precision=GEOHASH_PRECISION)
geohashes.append(center_geohash)
geohash_stack.add(center_geohash)
checked_geohashes.add(center_geohash)
while len(geohash_stack) > 0:
current_geohash = geohash_stack.pop()
neighbors = geohash.neighbors(current_geohash)
for neighbor in neighbors:
if neighbor not in checked_geohashes and is_geohash_in_bounding_box(
neighbor, bbox_coordinates):
geohashes.append(neighbor)
geohash_stack.add(neighbor)
checked_geohashes.add(neighbor)
return geohashes
def make_neighbors(geohashlist,firstlast=False): if firstlast == True: newlist = [] for row in geohashlist: add = geohash.neighbors(row) newlist += add newlist = np.unique(newlist).tolist() return newlist first = geohashlist[0] newlist = [first] last = geohashlist[-1] for ghash in geohashlist[1:-1]: add = geohash.neighbors(ghash) newlist += add newlist.append(last) newlist = np.unique(newlist).tolist() return newlist
def generate_tangs(geohashlist,positions): geohashlist = [i[:-1] for i in geohashlist] geohashlist = flatten_nonsorted(geohashlist) geohashlist = [geohash.neighbors(i) for i in geohashlist] if len(positions) == 6: geohashlist = [[i[positions[0]],i[positions[1]],i[positions[2]],i[positions[3]],i[positions[4]],i[positions[5]]] for i in geohashlist] else: geohashlist = [[i[positions[0]],i[positions[1]]] for i in geohashlist] return sum(geohashlist,[])
def get_candidate_points(self, latitude, longitude):
code = geohash.encode(latitude, longitude)[:self.precision]
candidates = OrderedDict()
candidates.update([(k, None) for k in self.index.get(code, [])])
for neighbor in geohash.neighbors(code):
candidates.update([(k, None) for k in self.index.get(neighbor, [])])
return candidates.keys()
def geo_aliases(cls, total_docs_by_geo, min_doc_count=1000):
keep_geos = total_docs_by_geo.filter(
lambda geo_count: geo_count[1] >= min_doc_count)
alias_geos = total_docs_by_geo.subtract(keep_geos)
return list(alias_geos.keys()) \
.flatMap(lambda key: [(neighbor, key) for neighbor in geohash.neighbors(key)]) \
.join(keep_geos) \
.map(lambda neighbor_key_count: (neighbor_key_count[1][0], (neighbor_key_count[0], neighbor_key_count[1][1]))) \
.groupByKey() \
.map(lambda key_values: (key_values[0], sorted(key_values[1], key_values[0]=operator.itemgetter(1), reverse=True)[0][0]))
def geo_aliases(cls, total_docs_by_geo, min_doc_count=1000):
keep_geos = total_docs_by_geo.filter(
lambda (geo, count): count >= min_doc_count)
alias_geos = total_docs_by_geo.subtract(keep_geos)
return alias_geos.keys() \
.flatMap(lambda key: [(neighbor, key) for neighbor in geohash.neighbors(key)]) \
.join(keep_geos) \
.map(lambda (neighbor, (key, count)): (key, (neighbor, count))) \
.groupByKey() \
.map(lambda (key, values): (key, sorted(values, key=operator.itemgetter(1), reverse=True)[0][0]))
def generate_neighbors(latitude, longitude, precision=5):
"""
Generates neighbors of given coordinates and includes the coordinate itself.
"""
latitude, longitude = map(float, [latitude, longitude])
room = geohash.encode(latitude, longitude, precision=precision)
neighbors = geohash.neighbors(room)
neighbors.append(room)
return neighbors
def get_candidate_points(self, latitude, longitude):
code = geohash.encode(latitude, longitude)[:self.precision]
candidates = OrderedDict()
candidates.update([(k, None) for k in self.index.get(code, [])])
for neighbor in geohash.neighbors(code):
candidates.update([(k, None)
for k in self.index.get(neighbor, [])])
return candidates.keys()
def polygon_to_multi_length_geohashes(self, polygon: Polygon, precision: int) -> tuple:
"""
将目标几何图形切割成geohash，并输出包含与相交两个geohash字符串列表
Parameters
----------
polygon : shapely.geometry.Polygon
目标几何图形
precision : int, optional
所求geohash经度
Returns
----------
tuple
被目标几何图形包括的geohash字符串列表，与目标几何图形相交的geohash字符串列表
Examples
----------
>>> g = GeohashOperator()
>>> p = Polygon([[116.40233516693117, 39.95442126877703], [116.40233516693117, 39.95744689749303],
>>> [116.4070386902313, 39.95744689749303], [116.4070386902313, 39.95442126877703]])
>>> g.polygon_to_multi_length_geohashes(p, 7)
(
{'wx4g2cd', 'wx4g2ce', 'wx4g2cf', 'wx4g2cg', 'wx4g2cs', 'wx4g2cu'},
{'wx4g2c3', 'wx4g2c6', 'wx4g2c7', 'wx4g2c9', 'wx4g2cc', 'wx4g2ck', 'wx4g2cm', 'wx4g2ct', 'wx4g2cv',
'wx4g2f1', 'wx4g2f4', 'wx4g2f5', 'wx4g2fh','wx4g2fj'}
)
See Also
----------
geohash_to_polygon : 将Geohash字符串转成矩形
"""
inner_geohashes = set()
outer_geohashes = set()
intersect_geohashes = set()
testing_geohashes = queue.Queue()
testing_geohashes.put(geohash.encode(polygon.exterior.xy[1][0], polygon.exterior.xy[0][0], precision))
while not testing_geohashes.empty():
current_geohash = testing_geohashes.get()
if current_geohash not in inner_geohashes and current_geohash not in outer_geohashes:
current_polygon = self.geohash_to_polygon(current_geohash)
condition = polygon.intersects(current_polygon)
if condition:
if polygon.contains(current_polygon):
inner_geohashes.add(current_geohash)
elif polygon.intersects(current_polygon):
intersect_geohashes.add(current_geohash)
outer_geohashes.add(current_geohash)
else:
outer_geohashes.add(current_geohash)
for neighbor in geohash.neighbors(current_geohash):
if neighbor not in inner_geohashes and neighbor not in outer_geohashes:
testing_geohashes.put(neighbor)
return inner_geohashes, intersect_geohashes
def generate_neighbors(latitude, longitude, precision=5):
"""
Generates neighbors of given coordinates and includes the coordinate itself.
"""
latitude, longitude = map(float, [latitude, longitude])
room = geohash.encode(latitude, longitude, precision=precision)
neighbors = geohash.neighbors(room)
neighbors.append(room)
return neighbors
def execute(self, current_location: Location) -> Optional[Location]:
"""Execution of the Movement Evaluation Policy"""
if random.random() <= settings.COURIER_MOVEMENT_PROBABILITY:
current_geohash = geohash.encode(*current_location.coordinates, precision=6)
geohash_neighbors = geohash.neighbors(current_geohash)
destination_geohash = random.choice(geohash_neighbors)
destination_coordinates = geohash.decode(destination_geohash)
return Location(lat=destination_coordinates[0], lng=destination_coordinates[1])
return None
def _add_neighbors(self, cell):
if cell in self._computed_cells:
return
n = geohash.neighbors(cell)
def cond(c): return (c in self._computed_cells) or (c in self._cells)
n[:] = list(filterfalse(cond, n))
self._next_batch.update(n)
self._computed_cells.add(cell)
def _build_cell_tiles_from_shapefile(self, shpfile):
'''Computes all geohash tiles in the given shapefile
:param shapefile: shapefile
:return: a list of geohashes
'''
''' open shapefile'''
sf = shapefile.Reader(shpfile)
'''get features'''
shapes = sf.shapes()
if len(shapes) > 1:
print("More than one feature was found. Only first will be selected.")
input("Press Enter to continue...")
'''only use first feature'''
first_shp = shapes[0]
''' get shape type. only if shapetype is polygon'''
shape_type = first_shp.shapeType
if shape_type != 5:
handle_error(msg='Shapefile feature be a polygon')
''' get points coordinates for each point in the shape '''
points = first_shp.points
polygon = Polygon(points)
checked_geohashes = set()
geohash_stack = set()
geohashes = []
'''get center of bounding box, assuming the earth is flat'''
center_latitude = polygon.centroid.coords[0][1]
center_longitude = polygon.centroid.coords[0][0]
center_geohash = self.build_cell([center_longitude, center_latitude])
geohashes.append(center_geohash)
geohash_stack.add(center_geohash)
checked_geohashes.add(center_geohash)
while len(geohash_stack) > 0:
current_geohash = geohash_stack.pop()
neighbors = geohash.neighbors(current_geohash)
for neighbor in neighbors:
point = Point(geohash.decode(neighbor)[::-1])
if neighbor not in checked_geohashes and polygon.contains(point):
geohashes.append(neighbor)
geohash_stack.add(neighbor)
checked_geohashes.add(neighbor)
geohashes.sort()
return geohashes
def wishlist_nearby():
gh = get_user_geohash()
neighbors = geohash.neighbors(gh)
neighbors.append(gh)
neighborhood = "('"+"','".join(neighbors)+"')"
db = get_db()
cur = db.execute("select I.itm_name, I.prc, U.usr as owner, I.itm_id from items as I join users as U on I.usr=U.usr join (select * from wishlists as WI join users as US on WI.usr = US.usr) as W where U.usr!=? and W.usr=? and I.itm_name like '%'||W.wishstr||'%' and U.geohash in "+neighborhood+";",[g.user.id, g.user.id])
items = cur.fetchall()
return render_template("wishlist_nearby.html", user=g.user, items=items)
def lochasher(lines):
hashDict = {}
for line in lines:
if type(line[1]) != tuple:
hashed = Geohash.encode(round(float(line[0][0]),6),round(float(line[0][1]),6),7)
hashDict.setdefault(hashed,[]).append(line)
else:
hashed = Geohash.encode(round(float(line[0][1]),6),round(float(line[0][0]),6),7)
hashedneighbors = geohash.neighbors(hashed)
hashedneighbors.append(hashed)
hashDict.setdefault((' '.join(hashedneighbors),line[1]),[]).append(line)
return hashDict
def _add_neighbors(self, cell):
if cell in self._computed_cells:
return
n = geohash.neighbors(cell)
def cond(c):
return (c in self._computed_cells) or (c in self._cells)
n[:] = list(filterfalse(cond, n))
self._next_batch.update(n)
self._computed_cells.add(cell)
def _get_adjoining_hashes(self, hashcode, precision):
"""
Given a hash, find the nearest eight boxes (four adjacent,
four diagonal) to the box.
:param hashcode: Initial full geohash
:param precision: Level of precision, integer
:return:
"""
if precision > len(hashcode):
raise ValueError('Precision greater than hashcode size.')
reduced_hash = hashcode[:precision]
return geohash.neighbors(reduced_hash)
def _get_adjoining_hashes(self, hashcode, precision):
"""
Given a hash, find the nearest eight boxes (four adjacent,
four diagonal) to the box.
:param hashcode: Initial full geohash
:param precision: Level of precision, integer
:return:
"""
if precision > len(hashcode):
raise ValueError('Precision greater than hashcode size.')
reduced_hash = hashcode[:precision]
return geohash.neighbors(reduced_hash)
def region_neighbors(data, user_region=True):
region_pairs = set()
regions = set(data['region'])
if user_region:
regions = regions.union(set(data['user_region']))
for region in regions:
neighbors = geohash.neighbors(region)
for neighbor in neighbors:
if neighbor in regions:
if neighbor < region:
region_pairs.add((neighbor, region))
else:
region_pairs.add((region, neighbor))
return regions, region_pairs
def get_geohashes(self):
"""Get all the geohashes from this song."""
song_tags = self.get_stripped_tags()
geohashes = [
t.split(':')[1] for t in song_tags if t.startswith('geohash:')
]
if GEOHASH:
for ghash in geohashes[:]:
try:
geohashes.extend(geohash.neighbors(ghash))
except ValueError:
# invalid geohash
print("Invalid geohash: %s in %s - %s" %
(ghash, self.get_artist(), self.get_title()))
return geohashes
def get_geohashes(self):
"""Get all the geohashes from this song."""
song_tags = self.get_stripped_tags()
geohashes = [
t.split(':')[1] for t in song_tags if t.startswith('geohash:')]
if GEOHASH:
for ghash in geohashes[:]:
try:
geohashes.extend(geohash.neighbors(ghash))
except ValueError:
# invalid geohash
print(
"Invalid geohash: %s in %s - %s" % (
ghash, self.get_artist(), self.get_title()))
return geohashes
def expand(bbox, geoh, depth):
neighbors = geohash.neighbors(geoh)
for neighbor in neighbors:
other = geohash.bbox(neighbor)
if with_neighbors > depth:
expand(bbox, neighbor, depth + 1)
else:
if other['n'] > bbox['n']:
bbox['n'] = other['n']
if other['s'] < bbox['s']:
bbox['s'] = other['s']
if other['e'] > bbox['e']:
bbox['e'] = other['e']
if other['w'] < bbox['w']:
bbox['w'] = other['w']
def expand(bbox, geoh, depth):
neighbors = geohash.neighbors(geoh)
for neighbor in neighbors:
other = geohash.bbox(neighbor)
if with_neighbors > depth:
expand(bbox, neighbor, depth + 1)
else:
if other['n'] > bbox['n']:
bbox['n'] = other['n']
if other['s'] < bbox['s']:
bbox['s'] = other['s']
if other['e'] > bbox['e']:
bbox['e'] = other['e']
if other['w'] < bbox['w']:
bbox['w'] = other['w']
def near_dupe_hashes(cls,
address,
geohash_precision=DEFAULT_GEOHASH_PRECISION,
use_latlon=True,
use_city=False,
use_postal_code=False):
address_expansions = cls.component_expansions(address)
lat = address.get(Coordinates.LATITUDE)
lon = address.get(Coordinates.LONGITUDE)
postcode = safe_decode(address.get(AddressComponents.POSTAL_CODE,
u'')).strip()
city = safe_decode(address.get(AddressComponents.CITY, u'')).strip()
if not any(address_expansions):
return
if lat and lon and use_latlon and not (
(isclose(lat, 0.0) and isclose(lon, 0.0)) or lat >= 90.0
or lat <= -90.0):
geo = geohash.encode(lat, lon)[:geohash_precision]
geohash_neighbors = [geo] + geohash.neighbors(geo)
base_key = cls.GEOHASH_KEY_PREFIX
for keys in six.itertools.product(geohash_neighbors,
*address_expansions):
yield u'{}|{}'.format(base_key, u'|'.join(keys))
if postcode and use_postal_code:
postcode_expansions = expand_address(
postcode, address_components=ADDRESS_POSTAL_CODE)
base_key = cls.POSTCODE_KEY_PREFIX
for keys in six.itertools.product(postcode_expansions,
*address_expansions):
yield u'{}|{}'.format(base_key, u'|'.join(keys))
if city and use_city:
city_expansions = expand_address(
city, address_components=ADDRESS_TOPONYM)
base_key = cls.CITY_KEY_PREFIX
for keys in six.itertools.product(city_expansions,
*address_expansions):
yield u'{}|{}'.format(base_key, u'|'.join(keys))
def _build_cell_tiles_from_geojson(self, jsonfile):
'''Computes all geohash tiles in the given geojson file
:param jsonfile: geojson (polygon)
:return: a list of geohashes
'''
with open(jsonfile) as f:
try:
data = json.load(f)
polygon = shape(data["geometry"])
geom_type = polygon.geom_type
if geom_type != 'Polygon':
handle_error(
'SyntaxError',
'Invalid GEOJSON format: Must be a Polygon type')
checked_geohashes = set()
geohash_stack = set()
geohashes = []
'''get center of bounding box, assuming the earth is flat'''
center_longitude = polygon.centroid.coords[0][0]
center_latitude = polygon.centroid.coords[0][1]
center_geohash = self.build_cell(
[center_longitude, center_latitude])
geohashes.append(center_geohash)
geohash_stack.add(center_geohash)
checked_geohashes.add(center_geohash)
while len(geohash_stack) > 0:
current_geohash = geohash_stack.pop()
neighbors = geohash.neighbors(current_geohash)
for neighbor in neighbors:
point = Point(geohash.decode(neighbor)[::-1])
if neighbor not in checked_geohashes and polygon.contains(
point):
geohashes.append(neighbor)
geohash_stack.add(neighbor)
checked_geohashes.add(neighbor)
geohashes.sort()
return geohashes
except ValueError as e:
handle_error(msg='Invalid GEOJSON format')
def test_neighbors(self):
test = '9p'
expect = {
's': '9n',
'e': '9r',
'w': '8z',
'nw': 'bb',
'sw': '8y',
'ne': 'c2',
'se': '9q',
'n': 'c0',
'c': '9p'
}
result = geohash.neighbors(test)
for k in expect:
assert expect[k] == result[k]
def process_signals(self, signals, input_id='default'):
output_signals = []
for signal in signals:
precision = self.precision()
lat = self.lat(signal)
lng = self.lng(signal)
loc = geohash.encode(lat, lng, precision)
setattr(signal, 'results', loc)
print(signal)
if self.adj():
neighbors = geohash.neighbors(loc)
setattr(signal, 'neighbors', neighbors)
self.notify_signals(signals)
def polygon_to_geohashes(polygon, precision, inner=True):
"""
:param polygon: shapely polygon.
:param precision: int. Geohashes' precision that form resulting polygon.
:param inner: bool, default 'True'. If false, geohashes that are completely outside from the polygon are ignored.
:return: set. Set of geohashes that form the polygon.
"""
inner_geohashes = set()
outer_geohashes = set()
envelope = polygon.envelope
centroid = polygon.centroid
testing_geohashes = queue.Queue()
testing_geohashes.put(geohash.encode(centroid.y, centroid.x, precision))
while not testing_geohashes.empty():
current_geohash = testing_geohashes.get()
if current_geohash not in inner_geohashes and current_geohash not in outer_geohashes:
current_polygon = geohash_to_polygon(current_geohash)
condition = envelope.contains(
current_polygon) if inner else envelope.intersects(
current_polygon) and not envelope.touches(current_polygon)
if condition:
if inner:
if polygon.contains(current_polygon):
inner_geohashes.add(current_geohash)
else:
outer_geohashes.add(current_geohash)
else:
if polygon.intersects(
current_polygon
) and not polygon.touches(current_polygon):
inner_geohashes.add(current_geohash)
else:
outer_geohashes.add(current_geohash)
for neighbor in geohash.neighbors(current_geohash):
if neighbor not in inner_geohashes and neighbor not in outer_geohashes:
testing_geohashes.put(neighbor)
return inner_geohashes
def geohashes(geojson={}, precision=6, start_precision=2):
"""
Return the list of geohashes that interects the geojson.
"""
polygon = _polygon_from_geojson(geojson)
if not polygon:
return []
p = min(start_precision, precision)
center_geohash = get_center_geohash(polygon, precision=p)
_geohashes = [center_geohash] + gh.neighbors(center_geohash)
_geohashes = geohashes_polygon_intersection(polygon, _geohashes)
while p < precision:
_geohashes = _generate_inner_geohashes_for_geohashes(_geohashes)
_geohashes = geohashes_polygon_intersection(polygon, _geohashes)
p += 1
return _geohashes
def get_near_loc():
result_path = cache_path + 'near_loc.hdf'
if os.path.exists(result_path):
result = pd.read_hdf(result_path, 'w')
else:
import geohash
train = pd.read_csv(train_path)
test = pd.read_csv(test_path)
loc_list = train['geohashed_start_loc'].tolist() \
+ train['geohashed_end_loc'].tolist() \
+ test['geohashed_start_loc'].tolist()
loc_list = np.unique(loc_list)
result = []
for loc in loc_list:
nlocs = geohash.neighbors(loc)
nlocs.append(loc)
for nloc in nlocs:
result.append([loc, nloc])
result = pd.DataFrame(result, columns=['loc', 'near_loc'])
result.to_hdf(result_path, 'w', complib='blosc', complevel=5)
return result
def get_near_loc():
result_path = cache_path + 'near_loc.hdf'
if os.path.exists(result_path):
result = pd.read_hdf(result_path, 'w')
else:
import geohash
prop = pd.read_csv(prop_path)
parcel_geohash_dict = get_parcel_geohash_dict(7)
prop['geohash'] = prop['parcelid'].map(parcel_geohash_dict)
loc_list = prop['geohashed_start_loc'].tolist()
loc_list = np.unique(loc_list)
result = []
for loc in loc_list:
if loc is np.nan:
continue
nlocs = geohash.neighbors(loc)
nlocs.append(loc)
for nloc in nlocs:
result.append([loc, nloc])
result = pd.DataFrame(result, columns=['loc', 'near_loc'])
result.to_hdf(result_path, 'w', complib='blosc', complevel=5)
return result
def geohashes(geojson={}, precision=6, start_precision=2):
"""
Return the list of geohashes that interects the geojson.
"""
polygon = _polygon_from_geojson(geojson)
if not polygon:
return []
precision_init = precision
if precision_init >= 9:
precision -= 1
p = min(start_precision, precision)
center_geohash = get_center_geohash(polygon, precision=p)
_geohashes = [center_geohash] + gh.neighbors(center_geohash)
_geohashes = geohashes_polygon_intersection(polygon, _geohashes)
while p < precision:
_geohashes = _generate_inner_geohashes_for_geohashes(_geohashes)
_geohashes = geohashes_polygon_intersection(polygon, _geohashes)
p += 1
if precision_init < 9:
return _geohashes
inside_geohashes_coarse = geohashes_polygon_within(polygon, _geohashes)
inside_geohashes = _generate_inner_geohashes_for_geohashes(
inside_geohashes_coarse)
intersect_geohashes_coarse = list(
set(_geohashes) - set(inside_geohashes_coarse))
intersect_geohashes = _generate_inner_geohashes_for_geohashes(
intersect_geohashes_coarse)
intersect_geohashes = geohashes_polygon_intersection(
polygon, intersect_geohashes)
return inside_geohashes + intersect_geohashes
def _compute_geohash_tiles(bbox_coordinates, geohash_precision):
"""
Computes all geohash tile in the given bounding box
(modified from https://blog.tafkas.net/2018/09/28/creating-a-grid-based-on-geohashes/)
Args:
bbox_coordinates: the bounding box coordinates of the geohashes (minx, miny, maxx, maxy)
geohash_precision (int): geohash precision (level) of output geohashes
Returns:
list: geohashes
"""
checked_geohashes = set()
geohash_stack = set()
geohashes = []
# get center of bounding box, assuming the earth is flat ;)
center_latitude = (bbox_coordinates[1] + bbox_coordinates[3]) / 2
center_longitude = (bbox_coordinates[0] + bbox_coordinates[2]) / 2
center_geohash = geohash.encode(center_latitude,
center_longitude,
precision=geohash_precision)
geohashes.append(center_geohash)
geohash_stack.add(center_geohash)
checked_geohashes.add(center_geohash)
while len(geohash_stack) > 0:
current_geohash = geohash_stack.pop()
neighbors = geohash.neighbors(current_geohash)
for neighbor in neighbors:
if neighbor not in checked_geohashes and _is_geohash_in_bounding_box(
neighbor, bbox_coordinates):
geohashes.append(neighbor)
geohash_stack.add(neighbor)
checked_geohashes.add(neighbor)
return geohashes
# write on 2017/07/03 by chuan.sun
import itertools
import geohash
import pandas as pd
# import python-geohash
# from geohash import encode,decode,adjacent, neighbors, neighborsfit
# geohash.neighbors("abx1")
df_geohash = pd.read_excel('D:/kfc.xlsx')
df_geohash['neighbors'] = 0
j = 0
for i in df_geohash.iloc[:, 2]:
# list_temp.append(geohash.neighbors(i))
df_geohash.iloc[j, 3] = str(geohash.neighbors(i))
j = j + 1
# print(df_geohash.head(10))
#
# a = [1, 2, 2, 2, 2]
# b = tuple(a)
# print(b)
#
# j = 0
# for i in df_geohash.iloc[:, 0]:
# nine_list = geohash.neighbors(i[0:5])
# list_temp = list()
# for x in nine_list:
# list_temp.append(geohash.neighbors(x))
# list_temp = list(itertools.chain.from_iterable(list_temp))
def test_one(self):
self.assertEqual(set(['1', '2', '3', 'p', 'r']), set(geohash.neighbors("0")))
self.assertEqual(set(['w', 'x', 'y', '8', 'b']), set(geohash.neighbors("z")))
self.assertEqual(set(['2', '6', '1', '0', '4', '9', '8', 'd']), set(geohash.neighbors("3")))
def index_point(self, lat, lon):
code = geohash.encode(lat, lon)[:self.precision]
for key in [code] + geohash.neighbors(code):
self.index[key].append(self.i)
self.points.extend([lat, lon])
def make_csvs(addgeohashs,csvfilenamealignment,csvfilenameneighbor,split,total,size):
aligns = pd.DataFrame(addgeohashs,columns=['GEOHASH','TEXT'])
print('Process %s: [%s/%s] dfsize created: %s' % (split,total,size,len(addgeohashs)))
addgeohashs = []
aligns = aligns.loc[np.unique(aligns['GEOHASH'],return_index=True)[1]]
# aggregating text
aligns['a'] = 'a'
totalneighbors = pd.DataFrame(str.split(aligns.groupby('a')['GEOHASH'].apply(lambda x: '|'.join(['|'.join(['|'.join(['%s,%s' % (ii,i) for i in geohash.neighbors(ii)])]) for ii in x.values]))['a'],'|'),columns=['TEXT'])
# slicing the text field to get the appropriate geohashs
totalneighbors['NEIGHBORS'] = totalneighbors['TEXT'].str[10:]
# doing total neighbors
totalneighbors = totalneighbors.loc[np.unique(totalneighbors['NEIGHBORS'],return_index=True)[1]]
# mapping the text to the neighboriing geohashs
totalneighbors['TEXT'] = aligns.set_index('GEOHASH').loc[totalneighbors['TEXT'].str[:9]]['TEXT'].values
aligns['TEXT'] = aligns['TEXT'].str[10:]
totalneighbors['TEXT'] = totalneighbors['TEXT'].str[10:]
# renaming neighbors headers
totalneighbors = totalneighbors[['NEIGHBORS','TEXT']]
totalneighbors.columns = ['GEOHASH','TEXT']
# exporting / appending both types to csv
with open(csvfilenameneighbor,'a') as f:
f.write('\n'+totalneighbors[['GEOHASH','TEXT']].to_csv(index=False,mode=str,header=False))
# exporting / appending to csv
with open(csvfilenamealignment,'a') as f:
f.write('\n'+aligns[['GEOHASH','TEXT']].to_csv(index=False,mode=str,header=False))
def test_one(self):
self.assertEqual(set(["1", "2", "3", "p", "r"]), set(geohash.neighbors("0")))
self.assertEqual(set(["w", "x", "y", "8", "b"]), set(geohash.neighbors("z")))
self.assertEqual(set(["2", "6", "1", "0", "4", "9", "8", "d"]), set(geohash.neighbors("3")))
def test_empty(self):
self.assertEqual([], geohash.neighbors(""))
def test_neighbors(self):
test = '9p'
expect = {'s': '9n', 'e': '9r', 'w': '8z', 'nw': 'bb', 'sw': '8y', 'ne': 'c2', 'se': '9q', 'n': 'c0', 'c':'9p'}
result = geohash.neighbors(test)
for k in expect:
assert expect[k] == result[k]
def neighbors_func(ghash): nei = geohash.neighbors(ghash) return '%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s' % (ghash,nei[0],ghash,nei[1],ghash,nei[2],ghash,nei[3],ghash,nei[4],ghash,nei[5],ghash,nei[6],ghash,nei[7])
def index_point(self, lat, lon, geohash_level):
code = geohash.encode(lat, lon)[:geohash_level]
for key in [code] + geohash.neighbors(code):
self.index[key].append(self.i)
def test_empty(self):
self.assertEqual([], geohash.neighbors(""))
def fetch_id(id):
key = "site:%s" % id
site = rds.get(key)
site = json.loads(site)
return site
if __name__ == '__main__':
lat, lon = sys.argv[1], sys.argv[2]
ghash = geohash.encode(float(lat), float(lon))
hashes = geohash.neighbors(ghash)
hashes.append(ghash)
sites = rds.zrange(sitekey, 0, -1, withscores = True)
hashmatches = {}
for chars in range(6,3,-1):
for sitehash, id in sites:
for currenthash in hashes:
if currenthash[0:chars] == sitehash[0:chars]:
hashmatches[sitehash] = int(id)
if len(hashmatches) > 0:
break
def geohash(cls, address):
geo = geohash.encode(address.latitude, address.longitude, cls.geohash_precision)
neighbors = geohash.neighbors(geo)
all_geo = [geo] + neighbors
return all_geo
import geohash
import json
coll = { "type": "FeatureCollection", "features": []}
h = geohash.encode(48.862004, 2.33734, precision=5)
cells = [h] + geohash.neighbors(h)
for cell in cells:
b = geohash.bbox(cell)
coordinates = []
coordinates.append( [ b['e'], b['s'] ])
coordinates.append( [ b['e'], b['n'] ])
coordinates.append( [ b['w'], b['n'] ])
coordinates.append( [ b['w'], b['s'] ])
coordinates.append( [ b['e'], b['s'] ])
feat = {
"type": "Feature",
"properties": {"name": cell},
"geometry": {
"type": "Polygon",
"coordinates": [ coordinates ]
}
}
coll["features"].append(feat)
print json.dumps(coll)
