def s2_to_geo_boundary(s2_address, geo_json_conformant=False): """Boundaries of given s2 square Parameters ---------- s2_address : string Unique s2 token geo_json : bool, optional If True, output coordinates is geo_json conformant (lng, lat) If False, coordinates are (lat, lng), by default False Returns ------- list Geometry of given s2 square """ cell = _token_to_cell(s2_address) return [ _to_lonlat(LatLng.from_point(cell.get_vertex(i))) for i in [0, 1, 2, 3, 0] ] if geo_json_conformant else [ _to_latlon(LatLng.from_point(cell.get_vertex(i))) for i in [0, 1, 2, 3] ]
def neighbor_s2_circle( location, i_dir=0.0, j_dir=0.0): # input location can be list, tuple or Point if type(location) in (list, tuple): ll_location = LatLng.from_degrees(location[0], location[1]) elif type(location) is Point: ll_location = LatLng.from_point(location) elif type(location) is LatLng: ll_location = location else: return None cid_large = CellId.from_lat_lng(ll_location).parent(lvl_big) cid_small = cid_large.child_begin(lvl_small) vec_to_j = (Cell(ij_offs(cid_small, 0, 1)).get_center() - Cell(cid_small).get_center()).normalize() vec_to_i = (Cell(ij_offs(cid_small, 1, 0)).get_center() - Cell(cid_small).get_center()).normalize() vec_newlocation = ll_location.to_point() + safety * HEX_R / earth_Rrect * ( i_dir * 3**0.5 * vec_to_i + j_dir * 1.5 * vec_to_j) return vec_newlocation # output is Point
async def _send_weather_webhook(self, s2cellId, weatherId, severe, warn, day, time): if self.__application_args.weather_webhook: log.debug("Send Weather Webhook") cell = Cell(CellId(s2cellId)) coords = [] for v in range(0, 4): vertex = LatLng.from_point(cell.get_vertex(v)) coords.append([vertex.lat().degrees, vertex.lng().degrees]) data = weather_webhook_payload.format(s2cellId, coords, weatherId, severe, warn, day, time) log.debug(data) payload = json.loads(data) log.info("Sending weather webhook: %s" % str(payload)) try: response = requests.post( self.__application_args.webhook_url, data=json.dumps(payload), headers={'Content-Type': 'application/json'}, timeout=5 ) if response.status_code != 200: log.warning("Go status code other than 200 OK from webhook destination: %s" % str(response.status_code)) else: log.info("Success sending webhook") except Exception as e: log.warning("Exception occured while sending webhook: %s" % str(e)) else: log.debug("Weather Webhook Disabled")
def locate_step(self, location): (lat, lon) = location origin = LatLng.from_degrees(lat, lon) parent = CellId.from_lat_lng(origin).parent(15) h = self.niantic.heartbit(location) hs = [h] for child in parent.children(): latlng = LatLng.from_point(Cell(child).get_center()) child_location = (latlng.lat().degrees, latlng.lng().degrees) hs.append(self.niantic.heartbit(child_location)) visible = self.__parse_pokemons(hs) current_time_ms = int(round(time.time() * 1000)) for poke in visible.values(): pokeid = str(poke.pokemon.PokemonId) pokename = POKEMON_NAMES[pokeid] expires = poke.LastModifiedMs + poke.TimeTillHiddenMs self.data.pokemons[poke.SpawnPointId] = { "lat": poke.Latitude, "lng": poke.Longitude, "expires": expires, 'expiresAfter': (expires - current_time_ms) / 1000, "id": poke.pokemon.PokemonId, "name": pokename } logger.debug('-- step {} {}: found {} pokemons, {} pokestops, {} gyms'.format( lat, lon, len(self.data.pokemons), len(self.data.pokestops), len(self.data.gyms)))
def writeplans(): subplans = request.args.get('subplans', type=int) plans = [] lock_plans.acquire() for token in list_plans: center = LatLng.from_point( Cell(CellId.from_token(token)).get_center()) center = (center.lat().degrees, center.lng().degrees) for ind_sub in range(1, subplans + 1): plans.append({ 'type': 'seikur0_s2', 'token': token, 'location': [center[0], center[1]], 'subplans': subplans, 'subplan_index': ind_sub }) lock_plans.release() for plan in plans: filename = '{}_{}_{}.plan'.format(plan['token'], plan['subplan_index'], plan['subplans']) try: f = open(plandir + '/' + filename, 'w', 0) json.dump(plan, f, indent=1, separators=(',', ': ')) print('[+] Plan file {} was written.'.format(filename)) except Exception as e: print( '[+] Error while writing plan file, error : {}'.format(e)) finally: if 'f' in vars() and not f.closed: f.close() return jsonify("")
def main(): origin_lat_i, origin_lng_i = f2i(origin_lat), f2i(origin_lng) api_endpoint, access_token, profile_response = login(origin_lat_i, origin_lng_i) with sqlite3.connect('database.db') as db: create_tables(db) while True: pos = 1 x = 0 y = 0 dx = 0 dy = -1 steplimit2 = steplimit**2 for step in range(steplimit2): #print('looping: step {} of {}'.format(step + 1, steplimit**2)) # Scan location math if -steplimit2 / 2 < x <= steplimit2 / 2 and -steplimit2 / 2 < y <= steplimit2 / 2: step_lat = x * 0.0025 + origin_lat step_lng = y * 0.0025 + origin_lng step_lat_i = f2i(step_lat) step_lng_i = f2i(step_lng) if x == y or x < 0 and x == -y or x > 0 and x == 1 - y: (dx, dy) = (-dy, dx) (x, y) = (x + dx, y + dy) #print('[+] Searching for Pokemon at location {} {}'.format(step_lat, step_lng)) origin = LatLng.from_degrees(step_lat, step_lng) parent = CellId.from_lat_lng(origin).parent(15) h = get_heartbeat(api_endpoint, access_token, profile_response, step_lat, step_lng, step_lat_i, step_lng_i) hs = [h] for child in parent.children(): latlng = LatLng.from_point(Cell(child).get_center()) child_lat, child_lng = latlng.lat().degrees, latlng.lng().degrees child_lat_i, child_lng_i = f2i(child_lat), f2i(child_lng) hs.append(get_heartbeat(api_endpoint, access_token, profile_response, child_lat, child_lng, child_lat_i, child_lng_i)) visible = [] data = [] for hh in hs: for cell in hh.cells: for poke in cell.WildPokemon: disappear_ms = cell.AsOfTimeMs + poke.TimeTillHiddenMs data.append(( poke.SpawnPointId, poke.pokemon.PokemonId, poke.Latitude, poke.Longitude, disappear_ms, )) if data: print('Upserting {} pokemon'.format(len(data))) with sqlite3.connect('database.db') as db: insert_data(db, data)
def add_plan(): location = (request.args.get('lat', type=float),request.args.get('lng', type=float)) all_loc,border,cid = mapl.get_area_cell(location,True) # grid = mapl.Hexgrid() # all_loc = grid.cover_cell(cid) center = LatLng.from_point(Cell(cid).get_center()) center = (center.lat().degrees, center.lng().degrees) token = cid.to_token() lock_plans.acquire() list_plans.append(token) lock_plans.release() return jsonify((all_loc, border,[center,token],[]))
def add_plan(): location = (request.args.get('lat', type=float), request.args.get('lng', type=float)) all_loc, border, cid = mapl.get_area_cell(location, True) # grid = mapl.Hexgrid() # all_loc = grid.cover_cell(cid) center = LatLng.from_point(Cell(cid).get_center()) center = (center.lat().degrees, center.lng().degrees) token = cid.to_token() lock_plans.acquire() list_plans.append(token) lock_plans.release() return jsonify((all_loc, border, [center, token], []))
def get_area_cell(location, unfilled=False): border = [] locs = [] cid_large = CellId.from_lat_lng( LatLng.from_degrees(location[0], location[1])).parent(lvl_big) border.append(get_border_cell(cid_large)) if unfilled: return [], border, cid_large corner = neighbor_s2_circle( LatLng.from_degrees(border[-1][0][0], border[-1][0][1]), safety_border * 0.5, safety_border / 3.0) j_maxpoint = LatLng.from_point( neighbor_s2_circle( LatLng.from_degrees(border[-1][1][0], border[-1][1][1]), safety_border * 0.5, (1 - safety_border) / 3.0)) i_maxpoint = LatLng.from_point( neighbor_s2_circle( LatLng.from_degrees(border[-1][3][0], border[-1][3][1]), (1 - safety_border) * 0.5, safety_border / 3.0)) base = corner p_start = base dist_j = j_maxpoint.get_distance(LatLng.from_point(p_start)) last_dist_j = None j = 0 while last_dist_j is None or dist_j < last_dist_j: dist_i = i_maxpoint.get_distance(LatLng.from_point(p_start)) last_dist_i = None while last_dist_i is None or dist_i < last_dist_i: locs.append(LatLng.from_point(p_start)) p_start = neighbor_s2_circle(p_start, 1.0, 0.0) last_dist_i = dist_i dist_i = i_maxpoint.get_distance(LatLng.from_point(p_start)) base = neighbor_s2_circle(base, 0.0, 1.0) last_dist_j = dist_j dist_j = j_maxpoint.get_distance(LatLng.from_point(base)) if j % 2 == 1: p_start = base else: p_start = neighbor_s2_circle(base, -0.5, 0.0) j += 1 all_loc = [] for loc in locs: all_loc.append([loc.lat().degrees, loc.lng().degrees]) return all_loc, border, cid_large
def s2_to_geo(s2_address): """Get geometry from s2 token Parameters ---------- s2_address : string s2 unique token Returns ------- list Geometry of s2 square """ cell = _token_to_cell(s2_address) return _to_latlon(LatLng.from_point(cell.get_center()))
def neighbor_s2_circle(location, i_dir=0.0, j_dir=0.0): # input location can be list, tuple or Point if type(location) in (list, tuple): ll_location = LatLng.from_degrees(location[0], location[1]) elif type(location) is Point: ll_location = LatLng.from_point(location) elif type(location) is LatLng: ll_location = location else: return None cid_large = CellId.from_lat_lng(ll_location).parent(lvl_big) cid_small = cid_large.child_begin(lvl_small) vec_to_j = (Cell(ij_offs(cid_small, 0, 1)).get_center() - Cell(cid_small).get_center()).normalize() vec_to_i = (Cell(ij_offs(cid_small, 1, 0)).get_center() - Cell(cid_small).get_center()).normalize() vec_newlocation = ll_location.to_point() + safety * HEX_R / earth_Rrect * (i_dir * 3 ** 0.5 * vec_to_i + j_dir * 1.5 * vec_to_j) return vec_newlocation # output is Point
async def _send_weather_webhook(self, s2cellId, weatherId, severe, warn, day, time): if self.__application_args.weather_webhook: log.debug("Send Weather Webhook") cell = Cell(CellId(s2cellId)) coords = [] for v in range(0, 4): vertex = LatLng.from_point(cell.get_vertex(v)) coords.append([vertex.lat().degrees, vertex.lng().degrees]) data = weather_webhook_payload.format(s2cellId, coords, weatherId, severe, warn, day, time) log.debug(data) payload = json.loads(data) self.__sendToWebhook(payload) else: log.debug("Weather Webhook Disabled")
def get_meta_cell(self): location = self.position[0:2] cells = self.find_close_cells(*location) # Combine all cells into a single dict of the items we care about. forts = [] wild_pokemons = [] catchable_pokemons = [] nearby_pokemons = [] for cell in cells: if "forts" in cell and len(cell["forts"]): forts += cell["forts"] if "wild_pokemons" in cell and len(cell["wild_pokemons"]): wild_pokemons += cell["wild_pokemons"] if "catchable_pokemons" in cell and len(cell["catchable_pokemons"]): catchable_pokemons += cell["catchable_pokemons"] if "nearby_pokemons" in cell and len(cell["nearby_pokemons"]): latlng = LatLng.from_point(Cell(CellId(cell["s2_cell_id"])).get_center()) for p in cell["nearby_pokemons"]: p["latitude"] = latlng.lat().degrees p["longitude"] = latlng.lng().degrees p["s2_cell_id"] = cell["s2_cell_id"] nearby_pokemons += cell["nearby_pokemons"] # If there are forts present in the cells sent from the server or we don't yet have any cell data, return all data retrieved if len(forts) > 1 or not self.cell: return { "forts": forts, "wild_pokemons": wild_pokemons, "catchable_pokemons": catchable_pokemons, "nearby_pokemons": nearby_pokemons } # If there are no forts present in the data from the server, keep our existing fort data and only update the pokemon cells. else: return { "forts": self.cell["forts"], "wild_pokemons": wild_pokemons, "catchable_pokemons": catchable_pokemons, "nearby_pokemons": nearby_pokemons }
def send_weather_webhook(s2cellId, weatherId, severe, warn, day, time): if args.weather_webhook: log.debug("Send Weather Webhook") cell = Cell(CellId(s2cellId)) coords = [] for v in range(0, 4): vertex = LatLng.from_point(cell.get_vertex(v)) coords.append([vertex.lat().degrees, vertex.lng().degrees]) data = weather_webhook_payload.format(s2cellId, coords, weatherId, severe, warn, day, time) log.debug(data) payload = json.loads(data) response = requests.post(args.webhook_url, data=json.dumps(payload), headers={'Content-Type': 'application/json'}) else: log.debug("Weather Webhook Disabled")
def get_search_points(self, cell_id): points = [] # For cell level 15 for c in Cell(CellId(cell_id)).subdivide(): for cc in c.subdivide(): latlng = LatLng.from_point(cc.get_center()) point = (latlng.lat().degrees, latlng.lng().degrees) points.append(point) points[0], points[1] = points[1], points[0] points[14], points[15] = points[15], points[14] point = points.pop(2) points.insert(7, point) point = points.pop(13) points.insert(8, point) closest = min(points, key=lambda p: great_circle(self.bot.position, p).meters) index = points.index(closest) return points[index:] + points[:index]
def get_area_cell(location,unfilled=False): border = [] locs = [] cid_large = CellId.from_lat_lng(LatLng.from_degrees(location[0], location[1])).parent(lvl_big) border.append(get_border_cell(cid_large)) if unfilled: return [], border, cid_large corner = neighbor_s2_circle(LatLng.from_degrees(border[-1][0][0], border[-1][0][1]), safety_border*0.5, safety_border/3.0) j_maxpoint = LatLng.from_point(neighbor_s2_circle(LatLng.from_degrees(border[-1][1][0], border[-1][1][1]), safety_border*0.5, (1-safety_border)/3.0)) i_maxpoint = LatLng.from_point(neighbor_s2_circle(LatLng.from_degrees(border[-1][3][0], border[-1][3][1]), (1-safety_border)*0.5, safety_border/3.0)) base = corner p_start = base dist_j = j_maxpoint.get_distance(LatLng.from_point(p_start)) last_dist_j = None j = 0 while last_dist_j is None or dist_j < last_dist_j: dist_i = i_maxpoint.get_distance(LatLng.from_point(p_start)) last_dist_i = None while last_dist_i is None or dist_i < last_dist_i: locs.append(LatLng.from_point(p_start)) p_start = neighbor_s2_circle(p_start, 1.0, 0.0) last_dist_i = dist_i dist_i = i_maxpoint.get_distance(LatLng.from_point(p_start)) base = neighbor_s2_circle(base, 0.0, 1.0) last_dist_j = dist_j dist_j = j_maxpoint.get_distance(LatLng.from_point(base)) if j % 2 == 1: p_start = base else: p_start = neighbor_s2_circle(base, -0.5, 0.0) j += 1 all_loc = [] for loc in locs: all_loc.append([loc.lat().degrees, loc.lng().degrees]) return all_loc, border,cid_large
def writeplans(): subplans = request.args.get('subplans', type=int) plans = [] lock_plans.acquire() for token in list_plans: center = LatLng.from_point(Cell(CellId.from_token(token)).get_center()) center = (center.lat().degrees, center.lng().degrees) for ind_sub in range(1,subplans+1): plans.append({'type': 'seikur0_s2', 'token': token, 'location': [center[0],center[1]], 'subplans': subplans, 'subplan_index': ind_sub}) lock_plans.release() for plan in plans: filename = '{}_{}_{}.plan'.format(plan['token'],plan['subplan_index'],plan['subplans']) try: f = open(plandir+'/'+filename, 'w', 0) json.dump(plan, f, indent=1, separators=(',', ': ')) print('[+] Plan file {} was written.'.format(filename)) except Exception as e: print('[+] Error while writing plan file, error : {}'.format(e)) finally: if 'f' in vars() and not f.closed: f.close() return jsonify("")
def get_cell_edge(cell, edge=0): cell_edge = LatLng.from_point(cell.get_vertex(edge)) return cell_edge
def get_vertex(cell, v): vertex = LatLng.from_point(cell.get_vertex(v)) return (vertex.lat().degrees, vertex.lng().degrees)