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 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_named_neighbors(self, gh): ghs = {} gh_bbox = geohash.bbox(gh) for g in geohash.expand(gh): if gh == g: continue b = geohash.bbox(g) if gh_bbox['n'] == b['n'] and gh_bbox['w'] == b["e"]: ghs['L'] = g elif gh_bbox['n'] == b['n'] and gh_bbox['e'] == b["w"]: ghs['R'] = g elif gh_bbox['e'] == b['e'] and gh_bbox['n'] == b["s"]: ghs['U'] = g elif gh_bbox['e'] == b['e'] and gh_bbox['s'] == b["n"]: ghs['D'] = g elif gh_bbox['n'] == b['s'] and gh_bbox['w'] == b['e']: ghs['LU'] = g elif gh_bbox['n'] == b['s'] and gh_bbox['e'] == b['w']: ghs['RU'] = g elif gh_bbox['s'] == b['n'] and gh_bbox['w'] == b['e']: ghs['LD'] = g elif gh_bbox['s'] == b['n'] and gh_bbox['e'] == b['w']: ghs['RD'] = g return ghs
def get_neighborhood_by_corners(corner_sw, corner_ne, precision=6): hashcode_sw = _get_geohash_from_tuple(corner_sw, precision) hashcode_ne = _get_geohash_from_tuple(corner_ne, precision) (delta_lat, delta_lon) = _get_delta_from_geohash(hashcode_sw) box_sw, box_ne = geohash.bbox(hashcode_sw), geohash.bbox(hashcode_ne) step_lat = int(math.ceil((box_ne['s'] - box_sw['s']) / delta_lat)) step_lon = int(math.ceil((box_ne['e'] - box_sw['e']) / delta_lon)) dir_set = [(i, j) for i in range(step_lat + 1) for j in range(step_lon + 1)] hashes = [ get_neighbor_by_direction(hashcode_sw, dir_element) for dir_element in dir_set ] return hashes
def geohash_rect(hashcode, point): # (n,w) (n,p[1])--p1 (n,e) # @------*---@----------@ # | | | # | | | # | | | # | | | # @ | c @ # | | | # (p[0],w) *------p--------------* (p[0], e)--p2 # | | | | # p4 | | | # @------*---@----------@ # (s,w) (s,p[1])--p3 (s,e) box = geohash.bbox(hashcode) p1 = [box['n'], point[1]] p2 = [point[0], box['e']] p3 = [box['s'], point[1]] p4 = [point[0], box['w']] top = spherical_distance(point, p1) bottom = spherical_distance(point, p3) left = spherical_distance(point, p4) right = spherical_distance(point, p2) return (top, bottom, left, right)
def get_cell(self, lon, lat): """Get the cell that a coordinate pair (lat, lon) falls within.""" res = self.es.search( index=self.index, body={ "query": { "filtered": { "filter": { "geo_distance": { "distance": '0.1km', 'geometry.coordinates': [lon, lat] # lon, lat } }, }, }, 'aggregations': { 'grid': { 'geohash_grid': { 'field': 'geometry.coordinates', 'precision': self.precision } } } } ) buckets = res['aggregations']['grid']['buckets'] if buckets: cell_hash = buckets[0]['key'] cell = geohash.bbox(cell_hash) else: cell = None return cell
def geohash_shape(shape, precision, mode='intersect', threshold=None): """ Find list of geohashes to cover the shape :param shape: shape to cover :type shape: BaseGeometry :param precision: geohash precision :type precision: int :param mode: 'intersect' - all geohashes intersect the shape use 'threashold' option to specify a percentage of least coverage 'inside' - all geohashes inside the shape 'center' - all geohashes whose center is inside the shape :type mode: str :param threshold: percentage of least coverage :type threshold: float :return: list of geohashes :rtype: list """ (min_lon, min_lat, max_lon, max_lat) = shape.bounds hash_south_west = geohash.encode(min_lat, min_lon, precision) hash_north_east = geohash.encode(max_lat, max_lon, precision) box_south_west = geohash.decode_exactly(hash_south_west) box_north_east = geohash.decode_exactly(hash_north_east) per_lat = box_south_west[2] * 2 per_lon = box_south_west[3] * 2 lat_step = int(round((box_north_east[0] - box_south_west[0]) / per_lat)) lon_step = int(round((box_north_east[1] - box_south_west[1]) / per_lon)) hash_list = [] for lat in range(0, lat_step + 1): for lon in range(0, lon_step + 1): next_hash = neighbor(hash_south_west, [lat, lon]) if mode == 'center': (lat_center, lon_center) = decode(next_hash) if shape.contains(Point(lon_center, lat_center)): hash_list.append(next_hash) else: next_bbox = geohash.bbox(next_hash) next_bbox_geom = box(next_bbox['w'], next_bbox['s'], next_bbox['e'], next_bbox['n']) if mode == 'inside': if shape.contains(next_bbox_geom): hash_list.append(next_hash) elif mode == 'intersect': if shape.intersects(next_bbox_geom): if threshold is None: hash_list.append(next_hash) else: intersected_area = shape.intersection( next_bbox_geom).area if (intersected_area / next_bbox_geom.area) >= threshold: hash_list.append(next_hash) return hash_list
def addGeohashToCountry(self, countryCode, geohash): ''' using some complex geometry unioning here! ''' if geohash is None: return # Here's an optimisation - without which a 45M POI run was taking well over # 12 hours. We're drawing the largest regions using 3-digit geohashs, and # each POI will live in one of these. The calculation of "within" is really # expensive and I'd like to avoid doing it - so to dramatically cut the # time, the best way is to dramatically cut the number of times it's done. if len(geohash) != 3: return b = geohasher.bbox(geohash) polygon = Polygon([ (b['e'], b['n']), \ (b['w'], b['n']), \ (b['w'], b['s']), \ (b['e'], b['s']), \ (b['e'], b['n']) ]) try: countryPolygon = self.countrysPolygon[countryCode] if not polygon.within(countryPolygon): #multipoly = cascaded_union([countryPolygon, polygon]) multipoly = countryPolygon.union(polygon) self.countrysPolygon[countryCode] = multipoly except KeyError: self.countrysPolygon[countryCode] = polygon
def geohash_lonlac(self, geohash_code: str, location: str = 's') -> float: """ 求geohash字符串的边界经度/维度 Parameters ---------- geohash_code : str 目标geohash字符串 location : str, optional geohash字符串对应的栅格 s: 最小纬度, n: 最大纬度, e: 最大经度, w: 最小经度 Returns ---------- float 所求的最大(最小)的经(维)度 Example --------- >>> G = GeohashOperator() >>> G.geohash_lonlac('wx4ervz', 'n'), G.geohash_lonlac('wx4ervz', 'e') 39.979248046875, 116.3671875 >>> G.geohash_lonlac('wx4ervz', 's'), G.geohash_lonlac('wx4ervz', 'w') 39.977874755859375, 116.36581420898438 分别求一个geohash字符串对应围栏的最大纬度、最大经度; 最小维度、最小经度 """ return geohash.bbox(geohash_code)[location]
def get_edge_points(self): # search for edges edge_points = [] edge_detection = [ dict(empty='LU', notempty='', edge=('n', 'w')), dict(empty='RU', notempty='', edge=('n', 'e')), dict(empty='LD', notempty='', edge=('s', 'w')), dict(empty='RD', notempty='', edge=('s', 'e')), dict(empty=('LU',), notempty='LU', edge=('n', 'w')), dict(empty=('RU',), notempty='RU', edge=('n', 'e')), dict(empty=('LD',), notempty='LD', edge=('s', 'w')), dict(empty=('RD',), notempty='RD', edge=('s', 'e')), ] for gh in self.geohashes: neighbors = self._get_named_neighbors(gh) for detect in edge_detection: empty_passes = all(neighbors[direction] not in self.geohashes for direction in detect['empty']) notempty_passes = all(neighbors[direction] in self.geohashes for direction in detect['notempty']) if empty_passes and notempty_passes: x_name, y_name = detect['edge'] b = geohash.bbox(gh) edge_points.append((b[x_name], b[y_name])) return edge_points
def test_empty(self): self.assertEqual(geohash.bbox(''), { 's': -90.0, 'n': 90.0, 'w': -180.0, 'e': 180.0 })
def makeGoogleEarthBox(self,geo): bbox = geohash.bbox(geo) lowerleft = "%s,%s,elevation"%(bbox['w'],bbox['s']) upperleft = "%s,%s,elevation"%(bbox['w'],bbox['n']) lowerright = "%s,%s,elevation"%(bbox['e'],bbox['s']) upperright = "%s,%s,elevation"%(bbox['e'],bbox['n']) polygon = "%s %s %s %s %s"%(lowerleft,upperleft,upperright,lowerright,lowerleft) return polygon
def geohash_polygon(gh): """ Creates a polygon object given geohash alphanumeric string Args: gh: Geohash string """ b = geohash.bbox(gh) box = [(b['w'], b['s']), (b['w'], b['n']), (b['e'], b['n']), (b['e'], b['s'],), (b['w'], b['s'])] return Polygon([box])
def render(self,ax,alpha=.7,usePyLeaflet=False, minValueThreshold=-float('Inf'),logScale=True,colormapname='BlueRed'): if not usePyLeaflet or colormapname=='nothingRed': alpha=1.0 patches = [] values = [] colorvalues = [] for d in self.countPerGeohash.keys(): try: if (self.countPerGeohash[d]>minValueThreshold): bbox = geohash.bbox(d) rect = mpatches.Rectangle([ bbox['w'], bbox['s']], bbox['e'] - bbox['w'], bbox['n'] - bbox['s'], ec='none', lw=.1, fc='red', alpha=alpha) patches.append(rect) # values.append(self.countPerGeohash[d] \ # if self.countPerGeohash[d]<3 else self.countPerGeohash[d]+10) # colorvalues.append(self.countPerGeohash[d] \ # if self.countPerGeohash[d]<3 else self.countPerGeohash[d]+10) values.append(self.countPerGeohash[d]) colorvalues.append(self.countPerGeohash[d]) except KeyError: print("'"+d +"' is not a valid geohash.") try: maxval = max(values) minval = min(values) except ValueError: print('heatmap appears to be empty...') maxval = 1 minval = 0 p = PatchCollection(patches,cmap=plt.get_cmap(colormapname),alpha=alpha) # if usePyLeaflet: if (len(values)<100): p.set_edgecolors(np.array(['black' for x in values])) else: p.set_edgecolors(np.array(['#333333' if x<=2 \ else ('#666666' if x<=10 else 'black') for x in values])) # else: # p.set_edgecolors(np.array(['white' for x in values])) p.set_array(np.array(colorvalues)) if logScale: p.set_norm(colors.LogNorm(vmin=.01, vmax=maxval)) else: p.set_norm(colors.Normalize(vmin=0, vmax=maxval)) ax.add_collection(p) ax.set_xlim(self.bbox['w'], self.bbox['e']) ax.set_ylim(self.bbox['s'], self.bbox['n']) divider = make_axes_locatable(ax) cbar = plt.colorbar(p) cbar.set_clim(vmin=max(0,minval),vmax=maxval) cbar.update_normal(p) return
def geohash_h_w(hashcode): box = geohash.bbox(hashcode) hp1 = [box['n'], box['w']] hp2 = [box['s'], box['w']] wp1 = hp1 wp2 = [box['n'], box['e']] h = spherical_distance(hp1, hp2) w = spherical_distance(wp1, wp2) return (h, w)
def _geohash_to_shape(geohash): box = gh.bbox(geohash) coords = [ [box["w"], box["s"]], [box["w"], box["n"]], [box["e"], box["n"]], [box["e"], box["s"]], [box["w"], box["s"]], ] return shape({"type": "Polygon", "coordinates": [coords]})
def get_geocodes(self, bbox): """Return a list of keys covering a given area. Parameters: bbox -- Bounding box of the desired region. """ # TODO: Make this more efficient for sparse areas of the map. w, s, e, n = map(float, bbox) n = min(C.MAXGHLAT, n) # work around a geohash library s = min(C.MAXGHLAT, s) # limitation assert(w <= e and s <= n) gcset = set() gc = geohash.encode(s, w, self.precision) bl = geohash.bbox(gc) # Box containing point (s,w). s_ = bl['s']; while s_ < n: # Step south to north. w_ = bl['w'] gc = geohash.encode(s_, w_, self.precision) bb_sn = geohash.bbox(gc) # bounding box in S->N direction while w_ < e: # Step west to east. gcset.add(gc) bb_we = geohash.bbox(gc) # in W->E direction w_ = bb_we['e'] gc = geohash.encode(s_, w_, self.precision) s_ = bb_sn['n'] assert(len(gcset) > 0) return [gc for gc in gcset]
def get_geocodes(self, bbox): """Return a list of keys covering a given area. Parameters: bbox -- Bounding box of the desired region. """ # TODO: Make this more efficient for sparse areas of the map. w, s, e, n = map(float, bbox) n = min(C.MAXGHLAT, n) # work around a geohash library s = min(C.MAXGHLAT, s) # limitation assert (w <= e and s <= n) gcset = set() gc = geohash.encode(s, w, self.precision) bl = geohash.bbox(gc) # Box containing point (s,w). s_ = bl['s'] while s_ < n: # Step south to north. w_ = bl['w'] gc = geohash.encode(s_, w_, self.precision) bb_sn = geohash.bbox(gc) # bounding box in S->N direction while w_ < e: # Step west to east. gcset.add(gc) bb_we = geohash.bbox(gc) # in W->E direction w_ = bb_we['e'] gc = geohash.encode(s_, w_, self.precision) s_ = bb_sn['n'] assert (len(gcset) > 0) return [gc for gc in gcset]
def bbox2hash_one(bbox, hash_length): # just verify that the resulting hash boxes cover the whole bbox hashes = bbox2hash(bbox = bbox, hash_length = hash_length) arr = np.array\ ([[x['s'],x['w'],x['n'],x['e']] \ for x in [geohash.bbox(x) \ for x in bbox2hash(bbox,hash_length)]]) assert min(arr[:,0]) <= bbox[0] assert min(arr[:,1]) <= bbox[1] assert max(arr[:,2]) >= bbox[2] assert max(arr[:,3]) >= bbox[3]
def test_intersects(self): bboxes = { "u09wj5": False, # out "u09tvy": True, # partially in "u09tvz": True, # partially in "u09wj0": True, # partially in "u09wj2": False, # in "u09wje": True, # edge crosses } for hashcode, expected in bboxes.items(): bbox = geohash.bbox(hashcode) self.assertEqual(expected, self.polygon.intersects(bbox))
def random_latlong(geohash): dic = gh.bbox(geohash) # getting min, max lat/lng min_lng = dic.get('w') min_lat = dic.get('s') max_lng = dic.get('e') max_lat = dic.get('n') # generate random float between [min_lng, max_lng) long = np.random.uniform(min_lng, max_lng) # generate random float between [min_lat, max_lat) lat = np.random.uniform(min_lat, max_lat) return lat, long
def get_bounding_geohash(n, w, s, e): """Get the bounding geohash for a given geobox. The geohash will be the smallest geohash that completely contains the given geobox (and will usually be quite a bit larger). """ lat = 0.5 * (n + s) lng = 0.5 * (w + e) gh = geohash.encode(lat, lng) for x in xrange(12, 0, -1): hash_part = gh[:x] bbox = geohash.bbox(hash_part) if (bbox['n'] >= n and bbox['s'] <= s and bbox['w'] <= w and bbox['e'] >= e): return hash_part return ''
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 geohashCoordinates(self, geohash, alt=0): """ Returns a string representing the coordinates of a geohash in a style suitable for using with Polygons, starting at the NE corner and moving in an anti-clockwise direction.""" height = self.heightMultiplier * float(alt) bbox = geohasher.bbox(geohash) return """%s,%s,%d %s,%s,%d %s,%s,%d %s,%s,%d %s,%s,%d""" % ( \ bbox['e'], bbox['n'], height, \ bbox['w'], bbox['n'], height, \ bbox['w'], bbox['s'], height, \ bbox['e'], bbox['s'], height, \ bbox['e'], bbox['n'], height )
def test_one(self): seq = '0123456789bcdefghjkmnpqrstuvwxyz' sws = [(-90.0, -180.0), (-90.0, -135.0), (-45.0, -180.0), (-45.0, -135.0), (-90.0, -90.0), (-90.0, -45.0), (-45.0, -90.0), (-45.0, -45.0), (0.0, -180.0), (0.0, -135.0), (45.0, -180.0), (45.0, -135.0), (0.0, -90.0), (0.0, -45.0), (45.0, -90.0), (45.0, -45.0), (-90.0, 0.0), (-90.0, 45.0), (-45.0, 0.0), (-45.0, 45.0), (-90.0, 90.0), (-90.0, 135.0), (-45.0, 90.0), (-45.0, 135.0), (0.0, 0.0), (0.0, 45.0), (45.0, 0.0), (45.0, 45.0), (0.0, 90.0), (0.0, 135.0), (45.0, 90.0), (45.0, 135.0)] for i in zip(seq, sws): x = geohash.bbox(i[0]) self.assertEqual((x['s'], x['w']), i[1]) self.assertEqual(x['n'] - x['s'], 45) self.assertEqual(x['e'] - x['w'], 45)
def geohash_shape(self, shape, precision=12, mode='center', level=1, prefix=''): geohashes = [] for char in self._get_geohash_chars(): hash = prefix + char p = bbox(hash) box_shape = box(p['w'], p['s'], p['e'], p['n']) if mode == 'inside': if shape.contains(box_shape): geohashes.extend([hash]) elif level < precision and box_shape.intersects(shape): geohashes.extend( self.geohash_shape(shape, precision, mode, level + 1, hash)) elif mode == 'center': if shape.contains(box_shape): geohashes.extend([hash]) elif level < precision and box_shape.intersects(shape): sub_shape = box_shape.intersection(shape) geohashes.extend( self.geohash_shape(sub_shape, precision, mode, level + 1, hash)) elif level == precision: (lat, lon) = decode(str(hash)) if shape.contains(Point(lon, lat)): geohashes.append(hash) elif mode == 'intersect': if shape.contains(box_shape): geohashes.extend([hash]) elif level < precision and box_shape.intersects(shape): geohashes.extend( self.geohash_shape(shape, precision, mode, level + 1, hash)) elif level == precision and box_shape.intersects(shape): geohashes.append(hash) return geohashes
def debug(self, items, size=(800, 600), return_only=False, maptype="hybrid"): if maptype not in ('roadmap', 'satellite', 'hybrid', 'terrain'): raise TypeError('maptype not supported') polyenc = gpolyencode.GPolyEncoder() url = 'http://maps.googleapis.com/maps/api/staticmap?' url += 'size={}x{}&maptype={}&sensor=false&scale=2'.format( size[0], size[1], maptype) for (color_name, color_hex), item in zip(colornames, items): if isinstance(item, Area): polygons = item.get_polygons() for points in polygons: p = polyenc.encode([(p[1], p[0]) for p in points]) polyline_encoded = p['points'] url += '&path=fillcolor:0x{}|weight:0|enc:{}'.format( color_hex[1:], polyline_encoded) print "{}: {}".format(item, color_name) elif isinstance(item, basestring): gh = self.geohash(item) if gh: bbox = geohash.bbox(gh) points = [(bbox['n'], bbox['w']), (bbox['n'], bbox['e']), (bbox['s'], bbox['e']), (bbox['s'], bbox['w']), (bbox['n'], bbox['w'])] p = polyenc.encode([(p[1], p[0]) for p in points]) polyline_encoded = p['points'] url += '&path=color:0x{}|enc:{}'.format( color_hex[1:], polyline_encoded) print "{}: {}".format(item, color_name) else: raise TypeError() webbrowser.open_new_tab(url)
def geohash_to_multipolygon(self, geohashes, simplify=False): polys = [] for g in geohashes: box = bbox(g) polys.append( Polygon([ (box['w'], box['n']), (box['e'], box['n']), (box['e'], box['s']), (box['w'], box['s']), ])) if simplify: polys = cascaded_union(polys) else: polys = MultiPolygon(polys) return mapping(polys)
def get_cells(self): """Get a mesh of geohash cells for all crimes in ElasticSearch at the chosen precision. """ res = self.es.search( index=self.index, body={ 'aggregations': { 'grid': { 'geohash_grid': { 'field': 'geometry.coordinates', 'precision': self.precision } } } } ) hashes = (bucket['key'] for bucket in res['aggregations']['grid']['buckets']) return (geohash.bbox(h) for h in hashes)
def test_one(self): seq = "0123456789bcdefghjkmnpqrstuvwxyz" sws = [ (-90.0, -180.0), (-90.0, -135.0), (-45.0, -180.0), (-45.0, -135.0), (-90.0, -90.0), (-90.0, -45.0), (-45.0, -90.0), (-45.0, -45.0), (0.0, -180.0), (0.0, -135.0), (45.0, -180.0), (45.0, -135.0), (0.0, -90.0), (0.0, -45.0), (45.0, -90.0), (45.0, -45.0), (-90.0, 0.0), (-90.0, 45.0), (-45.0, 0.0), (-45.0, 45.0), (-90.0, 90.0), (-90.0, 135.0), (-45.0, 90.0), (-45.0, 135.0), (0.0, 0.0), (0.0, 45.0), (45.0, 0.0), (45.0, 45.0), (0.0, 90.0), (0.0, 135.0), (45.0, 90.0), (45.0, 135.0), ] for i in zip(seq, sws): x = geohash.bbox(i[0]) self.assertEqual((x["s"], x["w"]), i[1]) self.assertEqual(x["n"] - x["s"], 45) self.assertEqual(x["e"] - x["w"], 45)
def test_one(self): seq = '0123456789bcdefghjkmnpqrstuvwxyz' sws = [ (-90.0, -180.0), (-90.0, -135.0), (-45.0, -180.0), (-45.0, -135.0), (-90.0, -90.0), (-90.0, -45.0), (-45.0, -90.0), (-45.0, -45.0), (0.0, -180.0), (0.0, -135.0), (45.0, -180.0), (45.0, -135.0), (0.0, -90.0), (0.0, -45.0), (45.0, -90.0), (45.0, -45.0), (-90.0, 0.0), (-90.0, 45.0), (-45.0, 0.0), (-45.0, 45.0), (-90.0, 90.0), (-90.0, 135.0), (-45.0, 90.0), (-45.0, 135.0), (0.0, 0.0), (0.0, 45.0), (45.0, 0.0), (45.0, 45.0), (0.0, 90.0), (0.0, 135.0), (45.0, 90.0), (45.0, 135.0) ] for i in zip(seq, sws): x = geohash.bbox(i[0]) self.assertEqual((x['s'], x['w']), i[1]) self.assertEqual(x['n']-x['s'], 45) self.assertEqual(x['e']-x['w'], 45)
def prepare_sentiment_rects(date_start, date_end): rects = [] for geo_sentiment in GeoSentiment.objects(date__gte=date_start, date__lt=date_end): bounds = geohash.bbox(geo_sentiment.geohash) sentiment = geo_sentiment.mean_sentiment rects.append({ 'fill_color': rgb2hex(sent2r(s=sentiment), sent2g(s=sentiment), 0), 'stroke_weight': 0, 'fill_opacity': 0.5, 'bounds': { 'north': bounds['n'], 'west': bounds['w'], 'south': bounds['s'], 'east': bounds['e'] } }) return rects
def do_geohashtogeojson(self, geoh): """Build GeoJSON corresponding to geohash given as parameter. GEOHASHTOGEOJSON u09vej04 [NEIGHBORS 0|1|2]""" geoh, with_neighbors = self._match_option('NEIGHBORS', geoh) bbox = geohash.bbox(geoh) try: with_neighbors = int(with_neighbors) except TypeError: with_neighbors = 0 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'] if with_neighbors > 0: expand(bbox, geoh, 0) geojson = { "type": "Polygon", "coordinates": [[ [bbox['w'], bbox['n']], [bbox['e'], bbox['n']], [bbox['e'], bbox['s']], [bbox['w'], bbox['s']], [bbox['w'], bbox['n']] ]] } print(white(json.dumps(geojson)))
def as_geo_json_bbox(self): """ Returns a GeoJSON polygon dict representing bounding box that surrounds this bucket. :return: a GeoJSON polygon dict """ bounding_box = geohash.bbox(self.key) return { "type": "Polygon", # note the reversal of the lat/lon and the double list wrap, it's cause this is GeoJSON "coordinates": [[ # top left corner [bounding_box['w'], bounding_box['n']], # top right corner [bounding_box['e'], bounding_box['n']], # bottom right corner [bounding_box['e'], bounding_box['s']], # bottom left corner [bounding_box['w'], bounding_box['s']], ]], }
def innerGeohashKML(self, geohash, innerDir): bbox = geohasher.bbox(geohash) return """ <NetworkLink> <name>%s</name> <Region> <LatLonAltBox> <north>%s</north> <south>%s</south> <east>%s</east> <west>%s</west> </LatLonAltBox> <Lod> <minLodPixels>32</minLodPixels> <maxLodPixels>768</maxLodPixels> </Lod> </Region> <Link> <href>./%s/index.kml</href> <viewRefreshMode>onRegion</viewRefreshMode> </Link> </NetworkLink>""" % (geohash, bbox['n'], bbox['s'], bbox['e'], bbox['w'], innerDir)
def do_geohashtogeojson(self, geoh): """Build GeoJSON corresponding to geohash given as parameter. GEOHASHTOGEOJSON u09vej04 [NEIGHBORS 0|1|2]""" geoh, with_neighbors = self._match_option('NEIGHBORS', geoh) bbox = geohash.bbox(geoh) try: with_neighbors = int(with_neighbors) except TypeError: with_neighbors = 0 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'] if with_neighbors > 0: expand(bbox, geoh, 0) geojson = { "type": "Polygon", "coordinates": [[[bbox['w'], bbox['n']], [bbox['e'], bbox['n']], [bbox['e'], bbox['s']], [bbox['w'], bbox['s']], [bbox['w'], bbox['n']]]] } print(white(json.dumps(geojson)))
def hashcodes(self, hashlength=10): west_set, east_set, hashcodes = set(), set(), set() row_hashcode = geohash.encode(latitude=self.__bbox["s"], longitude=self.__bbox["w"], precision=hashlength) row_bbox = geohash.bbox(row_hashcode) while row_bbox["s"] < self.__bbox["n"]: cell_hashcode = row_hashcode cell_bbox = row_bbox while is_west(cell_bbox["w"], self.__bbox["e"]): if self.__is_included(cell_bbox): west_set.add(cell_hashcode) break cell_hashcode = east(cell_hashcode) cell_bbox = geohash.bbox(cell_hashcode) row_hashcode = north(row_hashcode) row_bbox = geohash.bbox(row_hashcode) row_hashcode = geohash.encode(latitude=self.__bbox["s"], longitude=self.__bbox["e"], precision=hashlength) row_bbox = geohash.bbox(row_hashcode) while row_bbox["s"] < self.__bbox["n"]: cell_hashcode = row_hashcode cell_bbox = row_bbox while not is_west(cell_bbox["e"], self.__bbox["w"]): if self.__is_included(cell_bbox): east_set.add(cell_hashcode) break cell_hashcode = west(cell_hashcode) cell_bbox = geohash.bbox(cell_hashcode) row_hashcode = north(row_hashcode) row_bbox = geohash.bbox(row_hashcode) for hashcode in west_set: current = hashcode while current not in east_set: hashcodes.add(current) current = east(current) hashcodes.update(west_set) hashcodes.update(east_set) return hashcodes
def test_ezs42(self): x = geohash.bbox('ezs42') self.assertEqual(round(x['s'], 3), 42.583) self.assertEqual(round(x['n'], 3), 42.627)
import sys import time from math import cos, sqrt x = 25 y = 25 pre_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24] source = osr.SpatialReference() source.ImportFromEPSG(4326) target = osr.SpatialReference() target.ImportFromEPSG(26912) transform = osr.CoordinateTransformation(source, target) def dist_km(bbox1): #coords = (w,n) (w,s), (w, n) (e, n) R = 6371 x1 = (lon2 - lon1) * cos( 0.5*(lat2+lat1) ) y1 = lat2 - lat1 d1 = R * sqrt( x*x + y*y ) return d1 for i in pre_list: ghash = geohash.encode(x, y, precision=i) bboxname = "bbox_" + str(i) bboxname = geohash.bbox(ghash) print(bboxname) #dist = dist_km(bboxname) #print(dist)
import geohash print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=1))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=2))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=3))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=4))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=5))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=6))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=7))) print(geohash.bbox(geohash.encode(28.3613369, 75.5855657, precision=8)))
real_area = area(create_geojson( mapping(polygon)["coordinates"][0])) / 1000000 geohashes_polygon = polygon_to_geohashes(polygon, precision, False) polygon = geohashes_to_polygon(geohashes_polygon) perc_area = 100 * ( area(create_geojson(mapping(polygon)["coordinates"][0])) / 1000000) / real_area p_area.append(perc_area) geohash_num.append(len(compress(list(geohashes_polygon)))) if points: ps = [] for hash in compress(list(geohashes_polygon)): bbox = geohash.bbox(hash) lat1 = bbox['s'] lat2 = bbox['n'] lon1 = bbox['w'] lon2 = bbox['e'] ps.append(lat1) ps.append(lon1) ps.append(lat2) ps.append(lon1) ps.append(lat2) ps.append(lon2) ps.append(lat1) ps.append(lon2) f = open("fences_points.txt", "a") f.write(str(ps)) f.close()
def test_empty(self): self.assertEqual(geohash.bbox(""), {"s": -90.0, "n": 90.0, "w": -180.0, "e": 180.0})
def get_polygons(self): # search for edges edge_lines = [] edge_detection = [ ('U', (('n', 'w'), ('n', 'e'))), ('D', (('s', 'w'), ('s', 'e'))), ('L', (('n', 'w'), ('s', 'w'))), ('R', (('n', 'e'), ('s', 'e'))), ] for gh in self.geohashes: neighbors = self._get_named_neighbors(gh) for empty, ((x1_name, y1_name), (x2_name, y2_name)) in edge_detection: if neighbors[empty] not in self.geohashes: b = geohash.bbox(gh) edge_lines.append(((b[x1_name], b[y1_name]), (b[x2_name], b[y2_name]))) # merge all the lines to one path lines = list(edge_lines) while True: break_ = False found = False for (from_point1, to_point1) in lines: if break_: break for (from_point2, to_point2) in lines: if break_: break if (from_point1, to_point1) == (from_point2, to_point2): continue if to_point1 == from_point2 and ( from_point1[0] == to_point2[0] or from_point1[1] == to_point2[1]): new = (from_point1, to_point2) remove1 = (from_point1, to_point1) remove2 = (from_point2, to_point2) break_ = True found = True if not found: break lines.remove(remove1) lines.remove(remove2) lines.append(new) def get_next_line(all_lines, p): for (p1, p2) in all_lines: if p == p1: all_lines.remove((p1, p2)) return p2 if p == p2: all_lines.remove((p1, p2)) return p1 raise ValueError('no next line found') polygons = [] while True: polygon_points = [] try: # choose any point to begin with next_point = lines[0][0] except IndexError: break # aggregate all polygons while True: # find next point found = False for (p1, p2) in lines: if next_point == p1: lines.remove((p1, p2)) next_point = p2 found = True break if next_point == p2: lines.remove((p1, p2)) next_point = p1 found = True break if not found: break polygon_points.append(next_point) # "close the circle" polygon_points.append(polygon_points[0]) polygons.append(polygon_points) return polygons
def debug(self, *items, **kw): from string import ascii_uppercase import webbrowser import gpolyencode size = kw.get('size', (800, 600)) return_only = kw.get('return_only', False) maptype = kw.get('maptype', 'hybrid') assert maptype in ('roadmap', 'satellite', 'hybrid', 'terrain') ascii_labels = list(ascii_uppercase) number_labels = list('123456789') polyenc = gpolyencode.GPolyEncoder() draw_geohashes = [] for item in items: if isinstance(item, Area): use_label = True for gh in sorted(item.geohashes, reverse=True): draw_geohashes.append(('rect', gh, use_label, item)) use_label = False else: gh = self.geohash(item) draw_geohashes.append(('fill', gh, True, item)) used_labels = {} label_description = {} url = 'http://maps.googleapis.com/maps/api/staticmap?' url += 'size={}x{}&maptype={}&sensor=false&scale=2'.format(size[0], size[1], maptype) for cmd, gh, use_label, obj, in draw_geohashes: if use_label: # get the corresponding label label = used_labels.get(gh) if not label: try: label = (ascii_labels.pop(0) if cmd == 'fill' else number_labels.pop(0)) except IndexError: # * will be showed as a cirlce in google maps label = '*' used_labels[gh] = label if cmd == 'fill': latlon = geohash.decode(gh) url += '&markers=label:{label}|{lat},{lon}'.format( lat=round(latlon[0], 5), lon=round(latlon[1], 5), label=label) url += '&path=fillcolor:red|weight:0|' elif cmd == 'rect': if use_label: bbox = geohash.bbox(gh) url += '&markers=label:{label}|color:blue|{lat},{lon}'.format( lat=round(bbox['n'], 5), lon=round(bbox['e'], 5), label=label) url += '&path=' else: assert False bbox = geohash.bbox(gh) points = [(bbox['n'], bbox['w']), (bbox['n'], bbox['e']), (bbox['s'], bbox['e']), (bbox['s'], bbox['w']), (bbox['n'], bbox['w'])] p = polyenc.encode([(p[1], p[0]) for p in points]) polyline_encoded = p['points'] url += 'enc:{}'.format(polyline_encoded) if use_label: label_description.setdefault(label, []) label_description[label].append(obj) if return_only: return label_description, url else: # maybe the browser autocodes charachters so actually more are used print 'image: {} ({} chars, 2048 allowed)'.format(url, len(url)) print print 'image legend' print '------------' for label, objs in label_description.items(): print ' {} | {}'.format(label, ', '.join(str(i) for i in objs)) print '------------' webbrowser.open_new_tab(url)
def test_ezs42(self): x = geohash.bbox("ezs42") self.assertEqual(round(x["s"], 3), 42.583) self.assertEqual(round(x["n"], 3), 42.627)
def bboxes(self): return tuple(geohash.bbox(gh) for gh in self.geohashes)
def bbox(self, pin_id): # is this method a good idea? """Return the location of a pin as a bbox of the underlying geohash.""" gh = self.geohash(pin_id) return geohash.bbox(gh)
def bbox_scan(self, buffer=50): """Analog to :py:meth:`geohash_scan` return a bbox instead of the geohash.""" return ((pin, geohash.bbox(gh)) for pin, gh in self.geohash_scan(buffer))
def __init__(self, region): super(OSMGeoDoc, self).__init__(C.GEODOC, region) # Fill in default values for 'standard' fields. self.__setitem__(C.NODES, set()) self.__setitem__(C.BBOX, geohash.bbox(region))
def bbox_scan(self, buffer=50): return ((pin, geohash.bbox(gh)) for pin, gh in self.geohash_scan(buffer))
def decode_extent(extent): decoded = geohash.bbox(extent) return [decoded['w'], decoded['e'], decoded['s'], decoded['n']]
def get(self): motordb = self.settings['motordb'] print 'processing request' ### Process Bounds and Center arguments view_bounds_str = self.get_argument("bounds") view_center_str = self.get_argument("center") view_zoom_str = self.get_argument("zoom") view_zoom = int(view_zoom_str) if not view_bounds_str or not view_center_str: self.write([]) self.finish() return view_bounds_south, view_bounds_west, view_bounds_north, view_bounds_east = [float(x) for x in view_bounds_str.split(',')] view_center_lat, view_center_long = [float(x) for x in view_center_str.split(',')] view_bounds_width = abs(view_bounds_north - view_bounds_south) view_bounds_height = abs(view_bounds_east - view_bounds_west) #Do not use spacial reference system so that calculations are faster.. not needed view_bounds_ring = osgeo.ogr.Geometry(osgeo.ogr.wkbLinearRing) view_bounds_ring.TransformTo(WGS_84) view_bounds_ring.AddPoint(view_bounds_west, view_bounds_north) view_bounds_ring.AddPoint(view_bounds_east, view_bounds_north) view_bounds_ring.AddPoint(view_bounds_east, view_bounds_south) view_bounds_ring.AddPoint(view_bounds_west, view_bounds_south) view_bounds_ring.AddPoint(view_bounds_west, view_bounds_north) view_bounds_geom = osgeo.ogr.Geometry(osgeo.ogr.wkbPolygon) view_bounds_geom.TransformTo(WGS_84) view_bounds_geom.AddGeometry(view_bounds_ring) view_bounds_area = view_bounds_geom.Area() view_center_hash = geohash.encode(view_center_lat, view_center_long, precision=32) ###print "VIEW %.64f" % view_bounds_area possible_hashes = set(list('0123456789bcdefghjkmnpqrstuvwxyz')) if view_zoom == 5: end_precision = 0 if view_zoom == 6: end_precision = 0 if view_zoom == 7: end_precision = 1 if view_zoom == 8: end_precision = 2 if view_zoom == 9: end_precision = 2 if view_zoom == 10: end_precision = 3 if view_zoom == 11: end_precision = 4 if view_zoom == 12: end_precision = 5 if view_zoom == 13: end_precision = 6 if view_zoom == 14: end_precision = 6 if view_zoom == 15: end_precision = 7 end_precision = (view_zoom / 3) #perfect if end_precision > PRECISION: end_precision = PRECISION if end_precision < 0: end_precision = 0 if view_zoom < 8: end_precision = 0 ##print end_precision, '!!!' for precision in range(1,end_precision+1): new_possible_hashes = set([]) for possible_hash in possible_hashes: possible_hash_bbox = geohash.bbox(possible_hash) #Do not use spacial reference system possible_hash_ring = osgeo.ogr.Geometry(osgeo.ogr.wkbLinearRing) possible_hash_ring.TransformTo(WGS_84) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['n']) possible_hash_ring.AddPoint(possible_hash_bbox['e'], possible_hash_bbox['n']) possible_hash_ring.AddPoint(possible_hash_bbox['e'], possible_hash_bbox['s']) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['s']) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['n']) possible_hash_geom = osgeo.ogr.Geometry(osgeo.ogr.wkbPolygon) possible_hash_geom.TransformTo(WGS_84) possible_hash_geom.AddGeometry(possible_hash_ring) possible_hash_geom_intersection = view_bounds_geom.Intersection(possible_hash_geom) possible_hash_geom_intersection.TransformTo(WGS_84) possible_hash_area = possible_hash_geom_intersection.Area() if possible_hash_area or view_center_hash.startswith(possible_hash): ##print "!!!!", possible_hash, view_center_hash for hash_char in '0123456789bcdefghjkmnpqrstuvwxyz': new_possible_hashes.add(possible_hash + hash_char) possible_hashes = new_possible_hashes new_possible_hashes = set([]) new_possible_grandparent_hashes = set([]) for possible_hash in possible_hashes: possible_hash_bbox = geohash.bbox(possible_hash) #Do not use spacial reference system possible_hash_ring = osgeo.ogr.Geometry(osgeo.ogr.wkbLinearRing) possible_hash_ring.TransformTo(WGS_84) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['n']) possible_hash_ring.AddPoint(possible_hash_bbox['e'], possible_hash_bbox['n']) possible_hash_ring.AddPoint(possible_hash_bbox['e'], possible_hash_bbox['s']) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['s']) possible_hash_ring.AddPoint(possible_hash_bbox['w'], possible_hash_bbox['n']) possible_hash_geom = osgeo.ogr.Geometry(osgeo.ogr.wkbPolygon) possible_hash_geom.TransformTo(WGS_84) possible_hash_geom.AddGeometry(possible_hash_ring) possible_hash_geom_intersection = view_bounds_geom.Intersection(possible_hash_geom) possible_hash_geom_intersection.TransformTo(WGS_84) possible_hash_area = possible_hash_geom_intersection.Area() if possible_hash_area or view_center_hash.startswith(possible_hash): new_possible_hashes.update(geohash.expand(possible_hash)) new_possible_grandparent_hashes.add(possible_hash[0:-1]) possible_hashes = new_possible_hashes centroids = [] for hash in sorted(list(possible_hashes)): _lat, _long = geohash.decode(hash) centroids.append({ 'hash': hash, 'arg': True, 'lat': _lat, 'long': _long, }) lots = [] regions = [] region_set = set([]) query = {'parent': {'$in': list(possible_hashes)}} cursor = motordb.lots.find(query) print query self.update_region_cache() while (yield cursor.fetch_next): lot = cursor.next_object() lot['lot'] = True lot['bbox'] = geohash.bbox(lot['hash']) outline = osgeo.ogr.Geometry(wkb=str(lot['geom']['outline'])) outline.TransformTo(WGS_84) lot['geom']['outline'] = json.loads(osgeo.ogr.ForceToPolygon(outline).ExportToJson()) #geom = osgeo.ogr.ForceToPolygon(osgeo.ogr.Geometry(json.dumps(lot['geom']['outline'])).ConvexHull()) geom = outline.ConvexHull() if view_bounds_geom.Contains(geom) or view_bounds_geom.Intersects(geom) or view_zoom == 5: region_set.add(lot['region']['_id']) if view_zoom != 5: lots.append(lot) for region_oid in region_set: region = copy.deepcopy(self.settings['cache']['region']['map']['_id'][region_oid]) region['region'] = True outline = osgeo.ogr.Geometry(wkb=str(region['geom']['outline'])) outline.TransformTo(WGS_84) region['geom']['outline'] = json.loads(osgeo.ogr.ForceToPolygon(outline).ExportToJson()) regions.append(region) self.write(bson.json_util.dumps(sorted(regions, key=lambda x: x['order']) + lots)) self.finish() return
def bbox(self, pin_id): # is this method a good idea? gh = self.geohash(pin_id) return geohash.bbox(gh)