def getBoundingLatLngRectFromQueryRadiusInput(
self, QueryRadiusRequest: 'QueryRadiusRequest'):
centerPoint = QueryRadiusRequest.getCenterPoint()
radiusInMeter = QueryRadiusRequest.getRadiusInMeter()
centerLatLng = S2LatLng.from_degrees(centerPoint.getLatitude(),
centerPoint.getLongitude())
latReferenceUnit = -1.0 if centerPoint.getLatitude() > 0.0 else 1.0
latReferenceLatLng = S2LatLng.from_degrees(
centerPoint.getLatitude() + latReferenceUnit,
centerPoint.getLongitude())
lngReferenceUnit = -1.0 if centerPoint.getLongitude() > 0.0 else 1.0
lngReferenceLatLng = S2LatLng.from_degrees(
centerPoint.getLatitude(),
centerPoint.getLongitude() + lngReferenceUnit)
latForRadius = radiusInMeter / \
(centerLatLng.get_distance(latReferenceLatLng).radians * EARTH_RADIUS_METERS)
lngForRadius = radiusInMeter / \
(centerLatLng.get_distance(lngReferenceLatLng).radians * EARTH_RADIUS_METERS)
minLatLng = S2LatLng.from_degrees(
centerPoint.getLatitude() - latForRadius,
centerPoint.getLongitude() - lngForRadius)
maxLatLng = S2LatLng.from_degrees(
centerPoint.getLatitude() + latForRadius,
centerPoint.getLongitude() + lngForRadius)
return S2LatLngRect(minLatLng, maxLatLng)
def queryRadius(self, QueryRadiusInput: 'QueryRadiusRequest'):
latLngRect = S2Util().getBoundingLatLngRectFromQueryRadiusInput(
QueryRadiusInput)
covering = Covering(
self.config.S2RegionCoverer().get_covering(latLngRect))
results = self.dispatchQueries(covering, QueryRadiusInput)
filtered_results = self.filterByRadius(results, QueryRadiusInput)
if QueryRadiusInput.sort == True:
# Tuples list (distance to the center point, the point data returned from dynamoDB)
tuples = []
centerLatLng = S2LatLng.from_degrees(
QueryRadiusInput.getCenterPoint().getLatitude(),
QueryRadiusInput.getCenterPoint().getLongitude())
for item in filtered_results:
geoJson = item[self.config.geoJsonAttributeName]["S"]
coordinates = geoJson.split(",")
latitude = float(coordinates[0])
longitude = float(coordinates[1])
latLng = S2LatLng.from_degrees(latitude, longitude)
tuples.append((centerLatLng.get_distance(latLng).radians *
EARTH_RADIUS_METERS, item))
tuples.sort(key=lambda x: x[0]
) # Sort the list by distance (x [0] is the distance)
return [item[1] for item in tuples]
else:
return filtered_results
def cover_region_s2(location1,location2):
rc = RegionCoverer()
rc.max_level = lvl_big
rc.min_level = lvl_big
rc.max_cells = 1000
locations = []
if location1[0] > location2[0]:
lat1,lat2 = location2[0],location1[0]
else:
lat1, lat2 = location1[0], location2[0]
if location1[1] > location2[1]:
lng1, lng2 = location2[1], location1[1]
else:
lng1, lng2 = location1[1], location2[1]
lng1 = (lng1 + 180) % 360 - 180
lng2 = (lng2 + 180) % 360 - 180
lngs = []
if lng2 > lng1:
lngs.append((lng1,lng2))
elif lng2 < lng1:
lngs.append((-180.0,lng2))
lngs.append((lng1,180.0))
for lng1,lng2 in lngs:
cids = rc.get_covering(LatLngRect(LatLng.from_degrees(lat1,lng1),LatLng.from_degrees(lat2,lng2)))
for cid in cids:
ll_cid = cid.to_lat_lng()
locations.append((ll_cid.lat().degrees,ll_cid.lng().degrees))
return locations
def list_pokemon(self):
# todo: Check if client is Android/iOS/Desktop for geolink, currently
# only supports Android.
pokemon_list = []
# Allow client to specify location.
lat = request.args.get('lat', self.current_location[0], type=float)
lon = request.args.get('lon', self.current_location[1], type=float)
origin_point = LatLng.from_degrees(lat, lon)
for pokemon in convert_pokemon_list(
Pokemon.get_active(None, None, None, None)):
pokemon_point = LatLng.from_degrees(pokemon['latitude'],
pokemon['longitude'])
diff = pokemon_point - origin_point
diff_lat = diff.lat().degrees
diff_lng = diff.lng().degrees
direction = (('N' if diff_lat >= 0 else 'S')
if abs(diff_lat) > 1e-4 else '') +\
(('E' if diff_lng >= 0 else 'W')
if abs(diff_lng) > 1e-4 else '')
entry = {
'id':
pokemon['pokemon_id'],
'name':
pokemon['pokemon_name'],
'card_dir':
direction,
'distance':
int(
origin_point.get_distance(pokemon_point).radians *
6366468.241830914),
'time_to_disappear':
'%d min %d sec' % (divmod(
(pokemon['disappear_time'] - datetime.utcnow()).seconds,
60)),
'disappear_time':
pokemon['disappear_time'],
'disappear_sec':
(pokemon['disappear_time'] - datetime.utcnow()).seconds,
'latitude':
pokemon['latitude'],
'longitude':
pokemon['longitude']
}
pokemon_list.append((entry, entry['distance']))
pokemon_list = [y[0] for y in sorted(pokemon_list, key=lambda x: x[1])]
args = get_args()
visibility_flags = {
'custom_css': args.custom_css,
'custom_js': args.custom_js
}
return render_template('mobile_list.html',
pokemon_list=pokemon_list,
origin_lat=lat,
origin_lng=lon,
show=visibility_flags)
def get_cardinal_dir(pt_a, pt_b):
if len(pt_b) < 2:
return '?'
origin_point = LatLng.from_degrees(*pt_b)
lat_lng = LatLng.from_degrees(*pt_a)
diff = lat_lng - origin_point
diff_lat = diff.lat().degrees
diff_lng = diff.lng().degrees
direction = (('N' if diff_lat >= 0 else 'S') if abs(diff_lat) > 1e-4 else '') + \
(('E' if diff_lng >= 0 else 'W') if abs(diff_lng) > 1e-4 else '')
return direction
def get_dir(lat, lng):
origin_point = config.get("LOCATION")
if origin_point is None:
return "NoLocationSet" #No location set
origin_point = LatLng.from_degrees(origin_point[0], origin_point[1])
latLon = LatLng.from_degrees(lat, lng)
diff = latLon - origin_point
diff_lat = diff.lat().degrees
diff_lng = diff.lng().degrees
direction = (('N' if diff_lat >= 0 else 'S') if abs(diff_lat) > 1e-4 else '') + \
(('E' if diff_lng >= 0 else 'W') if abs(diff_lng) > 1e-4 else '')
return direction
def get_dir(lat, lng):
origin_point = config.get("LOCATION")
if origin_point is None:
return "NoLocationSet" #No location set
origin_point = LatLng.from_degrees(origin_point[0], origin_point[1])
latLon = LatLng.from_degrees(lat, lng)
diff = latLon - origin_point
diff_lat = diff.lat().degrees
diff_lng = diff.lng().degrees
direction = (('N' if diff_lat >= 0 else 'S') if abs(diff_lat) > 1e-4 else '') + \
(('E' if diff_lng >= 0 else 'W') if abs(diff_lng) > 1e-4 else '')
return direction
def latLngRectFromQueryRectangleInput(
self, QueryRectangleRequest: 'QueryRectangleRequest'):
queryRectangleRequest = QueryRectangleRequest
minPoint = queryRectangleRequest.getMinPoint()
maxPoint = queryRectangleRequest.getMaxPoint()
latLngRect = None
if minPoint is not None and maxPoint is not None:
minLatLng = S2LatLng.from_degrees(minPoint.getLatitude(),
minPoint.getLongitude())
maxLatLng = S2LatLng.from_degrees(maxPoint.getLatitude(),
maxPoint.getLongitude())
latLngRect = S2LatLngRect.from_point_pair(minLatLng, maxLatLng)
return latLngRect
def cover_square(lat, lng, width, level=15):
offset = int(width / 2)
g = Geodesic.WGS84 # @UndefinedVariable
r = RegionCoverer()
r.min_level, r.min_level = level, level
g1 = g.Direct(lat, lng, 360, offset)
g1 = g.Direct(g1['lat2'], g1['lon2'], 270, offset)
p1 = LatLng.from_degrees(g1['lat2'], g1['lon2'])
g2 = g.Direct(lat, lng, 180, offset)
g2 = g.Direct(g2['lat2'], g2['lon2'], 90, offset)
p2 = LatLng.from_degrees(g2['lat2'], g2['lon2'])
cells = r.get_covering(LatLngRect.from_point_pair(p1, p2))
return cells
def cover_square(lat, lng, width, level=15):
offset = int(width / 2)
g = Geodesic.WGS84 # @UndefinedVariable
r = RegionCoverer()
r.min_level, r.min_level = level, level
g1 = g.Direct(lat, lng, 360, offset)
g1 = g.Direct(g1['lat2'],g1['lon2'],270,offset)
p1 = LatLng.from_degrees(g1['lat2'],g1['lon2'])
g2 = g.Direct(lat, lng, 180, offset)
g2 = g.Direct(g2['lat2'],g2['lon2'], 90,offset)
p2 = LatLng.from_degrees(g2['lat2'],g2['lon2'])
cells = r.get_covering(LatLngRect.from_point_pair(p1, p2))
return cells
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 get_pokemons(self):
pokemon_list = []
origin_point = LatLng.from_degrees(self.location.latitude, self.location.longitude)
for pokemon in Pokemon.get_active():
pokemon_point = LatLng.from_degrees(pokemon['latitude'], pokemon['longitude'])
pokemon_list.append({
'id': pokemon['pokemon_id'],
'name': pokemon['pokemon_name'],
'time': '%02d:%02d' % (divmod((pokemon['disappear_time'] - datetime.utcnow()).seconds, 60)),
'latitude': pokemon['latitude'],
'longitude': pokemon['longitude']
})
return pokemon_list
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
def getCells(self, radius=10, bothDirections=True):
origin = CellId.from_lat_lng(
LatLng.from_degrees(
self.latitude,
self.longitude
)
).parent(15)
# Create walk around area
walk = [origin.id()]
right = origin.next()
left = origin.prev()
# Double the radius if we're only walking one way
if not bothDirections:
radius *= 2
# Search around provided radius
for _ in range(radius):
walk.append(right.id())
right = right.next()
if bothDirections:
walk.append(left.id())
left = left.prev()
# Return everything
return sorted(walk)
def getLatLongIndex(latitude, longitude):
return CellId.from_lat_lng(
LatLng.from_degrees(
latitude,
longitude
)
).id()
def getCells(self, radius=10, bothDirections=True):
origin = CellId.from_lat_lng(
LatLng.from_degrees(
self.latitude,
self.longitude
)
).parent(15)
# Create walk around area
walk = [origin.id()]
right = origin.next()
left = origin.prev()
# Double the radius if we're only walking one way
if not bothDirections:
radius *= 2
# Search around provided radius
for _ in range(radius):
walk.append(right.id())
right = right.next()
if bothDirections:
walk.append(left.id())
left = left.prev()
# Return everything
return sorted(walk)
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 getLatLongIndex(latitude, longitude):
return CellId.from_lat_lng(
LatLng.from_degrees(
latitude,
longitude
)
).id()
def getCellId(self):
return CellId.from_lat_lng(
LatLng.from_degrees(
self.latitude,
self.longitude
)
).parent(15)
def makeWildPokemon(location):
# Cause the randomness to only shift every N minutes (thus new pokes every N minutes)
offset = int(time() % 3600) / 10
seedid = str(location[0]) + str(location[1]) + str(offset)
seed(seedid)
# Now, collect the pokes for this can point
pokes = []
for i in range(randint(0, 2)):
coords = getRandomPoint(location)
ll = LatLng.from_degrees(coords[0], coords[1])
cellId = CellId.from_lat_lng(ll).parent(20).to_token()
pokes.append({
'encounter_id': 'pkm' + seedid + str(i),
'last_modified_timestamp_ms': int((time() - 10) * 1000),
'latitude': coords[0],
'longitude': coords[1],
'pokemon_data': {
'pokemon_id': randint(1, 140),
'iv_attack': 999999
},
'spawn_point_id': cellId,
'time_till_hidden_ms': randint(60, 600) * 1000
})
return pokes
def getNeighbors(location):
level = 15
origin = CellId.from_lat_lng(LatLng.from_degrees(location[0], location[1])).parent(level)
max_size = 1 << 30
size = origin.get_size_ij(level)
face, i, j = origin.to_face_ij_orientation()[0:3]
walk = [origin.id(),
origin.from_face_ij_same(face, i, j - size, j - size >= 0).parent(level).id(),
origin.from_face_ij_same(face, i, j + size, j + size < max_size).parent(level).id(),
origin.from_face_ij_same(face, i - size, j, i - size >= 0).parent(level).id(),
origin.from_face_ij_same(face, i + size, j, i + size < max_size).parent(level).id(),
origin.from_face_ij_same(face, i - size, j - size, j - size >= 0 and i - size >= 0).parent(level).id(),
origin.from_face_ij_same(face, i + size, j - size, j - size >= 0 and i + size < max_size).parent(level).id(),
origin.from_face_ij_same(face, i - size, j + size, j + size < max_size and i - size >= 0).parent(level).id(),
origin.from_face_ij_same(face, i + size, j + size, j + size < max_size and i + size < max_size).parent(level).id()]
#origin.from_face_ij_same(face, i, j - 2*size, j - 2*size >= 0).parent(level).id(),
#origin.from_face_ij_same(face, i - size, j - 2*size, j - 2*size >= 0 and i - size >=0).parent(level).id(),
#origin.from_face_ij_same(face, i + size, j - 2*size, j - 2*size >= 0 and i + size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i, j + 2*size, j + 2*size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i - size, j + 2*size, j + 2*size < max_size and i - size >=0).parent(level).id(),
#origin.from_face_ij_same(face, i + size, j + 2*size, j + 2*size < max_size and i + size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i + 2*size, j, i + 2*size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i + 2*size, j - size, j - size >= 0 and i + 2*size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i + 2*size, j + size, j + size < max_size and i + 2*size < max_size).parent(level).id(),
#origin.from_face_ij_same(face, i - 2*size, j, i - 2*size >= 0).parent(level).id(),
#origin.from_face_ij_same(face, i - 2*size, j - size, j - size >= 0 and i - 2*size >=0).parent(level).id(),
#origin.from_face_ij_same(face, i - 2*size, j + size, j + size < max_size and i - 2*size >=0).parent(level).id()]
return walk
def on_msg_published(self, message):
msg = json.loads(str(message))
'''
v_id = msg["v_id"]
if(self.vid != v_id):
log.msg("Got data that i did not subscribe, or subscribed earlier")
#ToDo: unsubscribe v_id
return
'''
if(self.is_heartbeat):
log.msg("Heartbeat notification returing")
return
if(self.is_live):
log.msg("Publishing live location to ", self.uid)
self.sendMessage(str(message))
if(self.is_notification):
loc = cyclone.escape.json_decode(message)
log.msg("Sending the notification:%r" % self.uid)
vlat = loc["latitude"]
vlon = loc["longitude"]
ulat = "12.8379176"
ulon = "77.6391782"
'''
#Inside websocket not able to query on db so hardcoding the ulat and ulon
rs = yield self.users.find({"_id": self.uid})
if len(rs):
ulat = rs["l_lattitude"]
ulon = rs["l_longitude"]
if(len(ulat)):
log.msg("Last lattitude available")
else:
log.msg("Last lattitude not available taking default value")
ulat = "12.8379176"
ulon = "77.6391782"
else:
log.msg("uid is not available")
'''
log.msg("vlat:%r vlon:%r ulat:%r ulon:%r" % (vlat, vlon, ulat, ulon))
distance = LatLng.from_degrees(float(vlat), float(vlon)).get_distance(LatLng.from_degrees(float(ulat), float(ulon))).radians
distance = distance * 6371
resp = {"resp_code": True,
"type": "distance",
"data": distance
}
log.msg(resp)
self.sendMessage(str(resp))
def update_missing_s2_ids():
log.info("Looking for spawn points with missing s2 coordinates")
for spawnpoint in db_load_spawn_points_missing_s2():
latlng = LatLng.from_degrees(spawnpoint["latitude"],
spawnpoint["longitude"])
cell = CellId.from_lat_lng(latlng).parent(15)
db_set_s2_cellid(spawnpoint["id"], cell.id())
log.info("Done establishing s2 points")
def _bbox_polyfill(
geo_json,
res,
):
"""returns list of S2 ids"""
lat, lon = _geo_json_to_extremes(geo_json)
p1 = LatLng.from_degrees(min(lat), min(lon))
p2 = LatLng.from_degrees(max(lat), max(lon))
region = LatLngRect.from_point_pair(p1, p2)
coverer = RegionCoverer()
coverer.min_level = res
coverer.max_level = res
return coverer.get_covering(region)
def filterByRadius(self, ItemList: 'points retrieved from dynamoDB',
QueryRadiusInput: 'QueryRadiusRequest'):
centerLatLng = S2LatLng.from_degrees(
QueryRadiusInput.getCenterPoint().getLatitude(),
QueryRadiusInput.getCenterPoint().getLongitude())
radiusInMeter = QueryRadiusInput.getRadiusInMeter()
result = []
for item in ItemList:
geoJson = item[self.config.geoJsonAttributeName]["S"]
coordinates = geoJson.split(",")
latitude = float(coordinates[0])
longitude = float(coordinates[1])
latLng = S2LatLng.from_degrees(latitude, longitude)
if (centerLatLng.get_distance(latLng).radians * EARTH_RADIUS_METERS
< radiusInMeter):
result.append(item)
return result
def get_s2_cell_center(lat, lng, level):
lat_lng = LatLng.from_degrees(lat, lng)
cell_id = CellId.from_lat_lng(lat_lng).parent(level)
center = cell_id.to_lat_lng()
return {
'lat': float(center.lat().degrees),
'lon': float(center.lng().degrees)
}
def cover_circle(lat, lng, radius, level):
EARTH_RADIUS = 6371 * 1000
region = Cap.from_axis_angle(LatLng.from_degrees(lat, lng).to_point(), \
Angle.from_degrees(360*radius/(2*math.pi*EARTH_RADIUS)))
coverer = RegionCoverer()
coverer.min_level = level
coverer.max_level = level
cells = coverer.get_covering(region)
return cells
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 remove_plan():
location = (request.args.get('lat', type=float), request.args.get('lng', type=float))
cid = CellId.from_lat_lng(LatLng.from_degrees(location[0],location[1])).parent(mapl.lvl_big)
token = cid.to_token()
lock_plans.acquire()
if token in list_plans:
list_plans.pop(list_plans.index(token))
lock_plans.release()
return jsonify("")
def sub_cell(cell,i=0,dist=25):
g = Geodesic.WGS84 # @UndefinedVariable
olat = CellId.to_lat_lng(cell).lat().degrees
olng = CellId.to_lat_lng(cell).lng().degrees
p = g.Direct(olat, olng,(45+(90*i)),dist)
c = CellId.from_lat_lng(LatLng.from_degrees(p['lat2'],p['lon2']))
return c.parent(cell.level()+1)
def cover_circle(lat, lng, radius, level=15):
EARTH = 6371000
region = Cap.from_axis_angle(\
LatLng.from_degrees(lat, lng).to_point(), \
Angle.from_degrees(360*radius/(2*math.pi*EARTH)))
coverer = RegionCoverer()
coverer.min_level = level
coverer.max_level = level
cells = coverer.get_covering(region)
return cells
def sub_cell(cell,i=0,dist=25):
g = Geodesic.WGS84 # @UndefinedVariable
olat = CellId.to_lat_lng(cell).lat().degrees
olng = CellId.to_lat_lng(cell).lng().degrees
p = g.Direct(olat, olng,(45+(90*i)),dist)
c = CellId.from_lat_lng(LatLng.from_degrees(p['lat2'],p['lon2']))
return c.parent(cell.level()+1)
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 get_cell_walk(lat, lng, radius, level=15):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, lng)).parent(level)
walk = [origin]
right = origin.next()
left = origin.prev()
for dummy in range(radius):
walk.append(right)
walk.append(left)
right = right.next()
left = left.prev()
return sorted(walk)
def get_cell_walk(lat, lng, radius, level=15):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, lng)).parent(level)
walk = [origin]
right = origin.next()
left = origin.prev()
for dummy in range(radius):
walk.append(right)
walk.append(left)
right = right.next()
left = left.prev()
return sorted(walk)
def remove_plan():
location = (request.args.get('lat', type=float),
request.args.get('lng', type=float))
cid = CellId.from_lat_lng(LatLng.from_degrees(
location[0], location[1])).parent(mapl.lvl_big)
token = cid.to_token()
lock_plans.acquire()
if token in list_plans:
list_plans.pop(list_plans.index(token))
lock_plans.release()
return jsonify("")
def get_cell_ids(lat, long, radius=1000):
# Max values allowed by server according to this comment:
# https://github.com/AeonLucid/POGOProtos/issues/83#issuecomment-235612285
if radius > 1500:
radius = 1500 # radius = 1500 is max allowed by the server
region = Cap.from_axis_angle(LatLng.from_degrees(lat, long).to_point(), Angle.from_degrees(360*radius/(2*math.pi*EARTH_RADIUS)))
coverer = RegionCoverer()
coverer.min_level = 15
coverer.max_level = 15
cells = coverer.get_covering(region)
cells = cells[:100] # len(cells) = 100 is max allowed by the server
return sorted([x.id() for x in cells])
def get_neighbors(lat, lon):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, lon)).parent(15)
walk = [origin.id()]
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return walk
def get_cell_ids(lat, long, radius=1000):
# Max values allowed by server according to this comment:
# https://github.com/AeonLucid/POGOProtos/issues/83#issuecomment-235612285
if radius > 1500:
radius = 1500 # radius = 1500 is max allowed by the server
region = Cap.from_axis_angle(LatLng.from_degrees(lat, long).to_point(), Angle.from_degrees(360*radius/(2*math.pi*EARTH_RADIUS)))
coverer = RegionCoverer()
coverer.min_level = 15
coverer.max_level = 15
cells = coverer.get_covering(region)
cells = cells[:100] # len(cells) = 100 is max allowed by the server
return sorted([x.id() for x in cells])
def special_getCoveringRect(lat, lng, radius):
radius_radians = earthMetersToRadians(radius)
latlng = LatLng.from_degrees(float(lat),
float(lng)).normalized().to_point()
region = Cap.from_axis_height(latlng,
(radius_radians * radius_radians) / 2)
coverer = RegionCoverer()
coverer.min_level = 5
coverer.max_level = 5
coverer.max_cells = MAX_S2_CELLS
covering = coverer.get_covering(region)
return covering
def get_cell_ids(lat, long, radius=500):
if radius > 500:
radius = 500
region = Cap.from_axis_angle(
LatLng.from_degrees(lat, long).to_point(),
Angle.from_degrees(360 * radius / (2 * math.pi * EARTH_RADIUS)))
coverer = RegionCoverer()
coverer.min_level = 15
coverer.max_level = 15
cells = coverer.get_covering(region)
cells = cells[:21]
return sorted([x.id() for x in cells])
def get_cellid(lat, long):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
walk = [origin.id()]
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return sorted(walk)
def get_neighbors(lat, lng):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, lng)).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return walk
def _get_cellid(self, lat, long, radius=10):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(radius):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return sorted(walk)
def cell_spiral(lat, lng, dist, level=15, step=100, res=3.6):
cells = []
g = Geodesic.WGS84 # @UndefinedVariable
for i in xrange(0, dist, step):
for rad in xrange(int(360 / res)):
p = g.Direct(lat, lng, rad * res, i)
c = CellId.from_lat_lng(LatLng.from_degrees(p['lat2'], p['lon2']))
c = c.parent(level)
if c not in cells: cells.append(c)
return cells
def _get_cellid(self, lat, long, radius=10):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(radius):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return sorted(walk)
def get_cellid(lat, lng, level=15):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, lng)).parent(level)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return sorted(walk)
def get_cellid(lat, long):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return ''.join(map(encode, sorted(walk)))
def list_pokemon(self):
# todo: check if client is android/iOS/Desktop for geolink, currently
# only supports android
pokemon_list = []
# Allow client to specify location
lat = request.args.get('lat', self.current_location[0], type=float)
lon = request.args.get('lon', self.current_location[1], type=float)
origin_point = LatLng.from_degrees(lat, lon)
for pokemon in Pokemon.get_active(None, None, None, None):
pokemon_point = LatLng.from_degrees(pokemon['latitude'],
pokemon['longitude'])
diff = pokemon_point - origin_point
diff_lat = diff.lat().degrees
diff_lng = diff.lng().degrees
direction = (('N' if diff_lat >= 0 else 'S')
if abs(diff_lat) > 1e-4 else '') +\
(('E' if diff_lng >= 0 else 'W')
if abs(diff_lng) > 1e-4 else '')
entry = {
'id': pokemon['pokemon_id'],
'name': pokemon['pokemon_name'],
'card_dir': direction,
'distance': int(origin_point.get_distance(
pokemon_point).radians * 6366468.241830914),
'time_to_disappear': '%d min %d sec' % (divmod((
pokemon['disappear_time'] - datetime.utcnow()).seconds, 60)),
'disappear_time': pokemon['disappear_time'],
'disappear_sec': (pokemon['disappear_time'] - datetime.utcnow()).seconds,
'latitude': pokemon['latitude'],
'longitude': pokemon['longitude']
}
pokemon_list.append((entry, entry['distance']))
pokemon_list = [y[0] for y in sorted(pokemon_list, key=lambda x: x[1])]
return render_template('mobile_list.html',
pokemon_list=pokemon_list,
origin_lat=lat,
origin_lng=lon)
def cell_spiral(lat, lng, dist, level=15, step=100, res=3.6):
cells = []
g = Geodesic.WGS84 # @UndefinedVariable
for i in xrange(0,dist,step):
for rad in xrange(int(360/res)):
p = g.Direct(lat, lng, rad*res, i)
c = CellId.from_lat_lng(LatLng.from_degrees(p['lat2'],p['lon2']))
c = c.parent(level)
if c not in cells: cells.append(c)
return cells
def get_cellid(lat, long):
origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next = origin.next()
prev = origin.prev()
for i in range(10):
walk.append(prev.id())
walk.append(next.id())
next = next.next()
prev = prev.prev()
return ''.join(map(encode, sorted(walk)))
def get_cell_ids(lat, long, radius = 10): origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15) walk = [origin.id()] right = origin.next() left = origin.prev() # Search around provided radius for i in range(radius): walk.append(right.id()) walk.append(left.id()) right = right.next() left = left.prev() # Return everything return sorted(walk)
def _get_cell_id_from_latlong(self, radius=10):
position_lat, position_lng, _ = self.api.get_position()
origin = CellId.from_lat_lng(LatLng.from_degrees(i2f(position_lat), i2f(position_lng))).parent(15)
walk = [origin.id()]
# 10 before and 10 after
next_cell = origin.next()
prev_cell = origin.prev()
for _ in range(radius):
walk.append(prev_cell.id())
walk.append(next_cell.id())
next_cell = next_cell.next()
prev_cell = prev_cell.prev()
return sorted(walk)
def filterByRectangle(self, ItemList: 'points retrieved from dynamoDB',
QueryRectangleInput: 'QueryRectangleRequest'):
latLngRect = S2Util().latLngRectFromQueryRectangleInput(
QueryRectangleInput)
result = []
for item in ItemList:
geoJson = item[self.config.geoJsonAttributeName]["S"]
coordinates = geoJson.split(",")
latitude = float(coordinates[0])
longitude = float(coordinates[1])
latLng = S2LatLng.from_degrees(latitude, longitude)
if (latLngRect.contains(latLng)):
result.append(item)
return result
def cover_cell(self, cid):
lats = []
lngs = []
output = []
s2_cell = Cell(cid)
lvl = s2_cell.level()
for i in [0, 1]:
for j in [0, 1]:
lats.append(s2_cell.get_latitude(i, j)/pi*180)
lngs.append(s2_cell.get_longitude(i, j)/pi*180)
locations = self.cover_region((min(lats),min(lngs)),(max(lats),max(lngs)))
for location in locations:
testid = CellId.from_lat_lng(LatLng.from_degrees(location[0],location[1])).parent(lvl)
if testid == cid:
output.append(location)
return output
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
def build_cap_coverage(lat, lng, cell_count=21, radius=100.0):
# these are the zoom levels for s2cells
min_zoom_level = 15
max_zoom_level = 30
# radius of the earth in meters
R = 6378137.0;
cap_height = ((radius/R)**2)/2
axis = LatLng.from_degrees(lat, lng).to_point()
cap = Cap.from_axis_height(axis, cap_height)
coverer = RegionCoverer()
coverer.min_level = min_zoom_level
coverer.max_level = max_zoom_level
coverer.max_cells = cell_count
covering = list(coverer.get_covering(cap))
while(len(covering) < cell_count):
covering.append(covering[-1].next())
return covering
def getCells(self, radius=10):
origin = CellId.from_lat_lng(
LatLng.from_degrees(
self.latitude,
self.longitude
)
).parent(15)
# Create walk around area
walk = [origin.id()]
right = origin.next()
left = origin.prev()
# Search around provided radius
for _ in range(radius):
walk.append(right.id())
walk.append(left.id())
right = right.next()
left = left.prev()
# Return everything
return sorted(walk)
def makeWildPokemon(location):
# Cause the randomness to only shift every N minutes (thus new pokes every N minutes)
offset = int(time() % 3600) / 10
seedid = str(location[0]) + str(location[1]) + str(offset)
seed(seedid)
# Now, collect the pokes for this can point
pokes = []
for i in range(randint(0, 2)):
coords = getRandomPoint(location)
ll = LatLng.from_degrees(coords[0], coords[1])
cellId = CellId.from_lat_lng(ll).parent(20).to_token()
pokes.append(
{
"encounter_id": "pkm" + seedid + str(i),
"last_modified_timestamp_ms": int((time() - 10) * 1000),
"latitude": coords[0],
"longitude": coords[1],
"pokemon_data": {"pokemon_id": randint(1, 140)},
"spawn_point_id": cellId,
"time_till_hidden_ms": randint(60, 600) * 1000,
}
)
return pokes
