def reverse_geocode(self, lat, lng): """get address for latitude/longitude""" if 'google' in self._args.provider: geocode = geocoder.google([lat, lng], method='reverse') elif 'osm' in self._args.provider: if not self._args.url: geocode = geocoder.osm([lat, lng], method='reverse') time.sleep(1) # Nominatim Usage Policy else: if 'localhost' in self._args.url: geocode = geocoder.osm([lat, lng], method='reverse', url='http://localhost/nominatim/search') else: geocode = geocoder.osm([lat, lng], method='reverse', url=self._args.url) else: self._parser.error("invalid provider given") raise ValueError('invalid provider given') if not geocode.ok: logging.error("geocoding failed or api limit exceeded") raise RuntimeError('geocoding failed or api limit exceeded') else: logging.debug(geocode.json) return geocode.json
def calc_address(address, when, output=CITIES_FILENAME): setup_output(output) logger.info('Querying the server for: "%s" ...', address) response = geocoder.osm(address) logger.info('Got an answer!') if not is_osmurl_valid(response): osmurl_invalid() return logger.info('Loading old cities from: %s', output) cities = load_json(output) osm_id = response.json['osm_id'] last_osm_id = None if cities[when]: last_osm_id = cities[when][-1]['osm_id'] if not cities[when] or osm_id != last_osm_id: logger.info('Adding new city: "%s"', response.address) cities[when].append(response.json) save_json(cities, output) else: logger.info('This city is already saved. Excluding...') return response
def getPoints(csvFile, fieldNameAddress, delimiter=',', quoting='"', decodeTo='utf8'): g = [] i = 0 with open(csvFile) as csvfile: reader = csv.DictReader(csvfile) for row in reader: direc = row[fieldNameAddress] direc = direc.decode(decodeTo) tmp_g = geocoder.osm(direc) listRow = [] for key in row: listRow.append(row[key]) try: listRow.append(tmp_g.x) listRow.append(tmp_g.y) except: listRow.append("err") listRow.append("err") #print(tmp_g.x) #print(tmp_g.y) g.append(listRow) i = i + 1 print(i) print(listRow) return g
def lookupPosition(self): #g = geocoder.osm('Deutschland, 21379, Scharnebeck, Hülsenberg 6') print self.toString() g = geocoder.osm(self.toString()) if (g.x == None)or(g.y == None): raise NameError("can't get lon/lat -> check your internet connection") return Position(g.y, g.x)
def test_multi_results(): g = geocoder.osm(location, maxRows='5') assert len(g) == 5 expected_results = [ 'Ottawa, Ontario, Canada', 'Ontario, Ottawa County, Oklahoma, United States of America', ] assert [result.address for result in g][:2] == expected_results
def calc_my_position_address(address, output, upload=True): logger.info('Querying the server about "%s"...', address) response = geocoder.osm(address) logger.info('LatLng: %s', response.latlng) logger.info('Place: %s', response.address) save_json(response.latlng, output) if upload: upload_my_position()
def get_addresses(verbose=False): with pymongo.connection.Connection(MONGO_HOST, MONGO_PORT) as conn: coll = conn['sbcatalog']['supplier'] suppliers_in = coll.find() suppliers_out = [] for s in suppliers_in: success = False x = {} x['name'] = s['name'] a = s['address'] # converting address to string address = "" for k in ['locality', 'zipcode', 'street']: if a[k]: address += a[k] + ' ' address = address[:-1] if verbose: print('"' + address + '"', end=' ') # trying with full address result = geocoder.osm(address).json if result['status'] == 'OK' and result['country'] == 'Italia': success = True # trying with only city elif a['locality']: if verbose: print('NOT FOUND! ' + '"' + a['locality'] + '"', end=' ') result = geocoder.osm(a['locality']).json success = result['status'] == 'OK' and result['country'] == 'Italia' if success: if verbose: print('OK!') x['coords'] = result['geometry']['coordinates'] x['address'] = address webSite = s['contacts']['contact']['primary']['webSite'] if webSite: x['webSite'] = webSite suppliers_out.append(x) return suppliers_out
def main(): import argparse import sys parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('address', metavar='text', nargs='+', help='an address to lookup (use "" when it\'s a sentence / more than one word)') args = parser.parse_args() location = geocoder.osm(args.address) sys.stdout.write(bcolors.OKBLUE + str(location.lat) + ", " + str(location.lng) + bcolors.ENDC) sys.stdout.write("\n")
def geocode(self, appartement): """Retrieve the lat and long using different fallback services""" g = geocoder.google(appartement["address"]) if not g.latlng: g = geocoder.osm(appartement["address"]) if not g.latlng and MAPQUEST_API_KEY: g = geocoder.mapquest(appartement["address"], key=MAPQUEST_API_KEY) # if we can't geocode the address, we return the map center if g.latlng: return g.latlng else: return MAP_LATLNG
def getgeo_osm(ip_list): count=1 latlng_set=[] for ip in ip_list: geoinfo = geocoder.osm(ip) print("[osm] {} ({}/{}) country: {}".format(ip, count, len(ip_list), geoinfo.json.get('country'))) if geoinfo.latlng: latlng_set.append([ip, geoinfo.latlng[0], geoinfo.latlng[1]]) else: print("{} not found".format(ip)) latlng_set.append([ip, "","" ]) count = count + 1 #print(latlng_set) return latlng_set
def geocode(self, address): """Retrieve the lat and long using different fallback services""" if GEOLOCALISE is False: return MAP_LATLNG g = geocoder.google(address) if not g.latlng: g = geocoder.osm(address) if not g.latlng and MAPQUEST_API_KEY: g = geocoder.mapquest(address, key=MAPQUEST_API_KEY) # if we can't geocode the address, we return the map center if g.latlng: return g.latlng else: return MAP_LATLNG
async def ip_address(ip: str): """Returns address and geographical coordinates of an IP.""" try: geolocator = geocoder.ip(ip) coord = geolocator.json['raw']['loc'].split(",") lat, lon = coord[0], coord[1] geolocator = geocoder.osm([lat, lon], method='reverse') address = geolocator.json['raw']['display_name'] data = { "source": "OSM", "longitude": lat, "latitude": lon, "address": address } return ResponseModel(data, "success") except Exception: return ErrorResponseModel(400, "Invalid IP_Address input.")
def get_fac(numadr): while True: adresses = [ 'wrocław', 'wałbrzych', 'Legnica', 'bolesławiec', 'ząbkowice śląskie ' ] adress = adresses[numadr] adress = geocoder.osm(adress) if not adress: print("Nie mogę znaleźć podanego adresu. Spróbuj jeszcze raz") continue else: break fac = adress.latlng fac.append(rn.randint(20, 40) * 100) fac.append(rn.randint(65000, 80000)) return fac
def get_lat_lon(place_name): # get geocode postion g = geocoder.osm(place_name) if g.ok == True: lat = g.json["lat"] lon = g.json["lng"] else: lat = 0.0 lon = 0.0 print("No LatLon") self.is_error[0] = 1 self.error_info = self.error_info + " " + 'Place ' + place_name + ' not found' return (str(lat), str(lon))
def process(self, address): fix_by_osm = True """check for address stuff like address numbers from-to""" if "-" in address: print "there is - in address, preprocessing" address = self.preProcess(address) self._df_add = getStandardAddress(address) engine = create_engine("postgresql://postgres:@128.31.25.188:5432/") self.processed_df = processGeocodeCall(self._df_add, engine) try: print "try: findin postgis" self._df_add = getStandardAddress(address) engine = create_engine( "postgresql://postgres:@128.31.25.188:5432/") self.processed_df = processGeocodeCall(self._df_add, engine) except: if fix_by_osm: print "except:fix by osm" address_formated = geocoder.osm("{0}".format(address)) address = "{0} {1}, {2} {3} {4}".format( address_formated.json["housenumber"], address_formated.json["street"], address_formated.json["city"], address_formated.json["state"], address_formated.json["postal"]) else: print "exept: fix by bing" address_formated = geocoder.bing( "{0}".format(address), key= "ApdsLDh8yd-ma4xCpdY-qbmYvUl7D9br_qvXYiYzXDz1PQqS_2khXrc5gYAJt88y" ) print "address json" address = address_formated.json["address"] # print address self._df_add = getStandardAddress(address) engine = create_engine( "postgresql://postgres:@128.31.25.188:5432/") self.processed_df = processGeocodeCall(self._df_add, engine) else: print "else" finally: return_df = self.prepare_results(self.processed_df) return return_df
def search(request): qs = Post.objects.all() location_query = request.GET.get('location') details_query = request.GET.get('details') user_query = request.GET.get('user') days_query = request.GET.get('days') people_query = request.GET.get('people') date_query = request.GET.get('date') gender_query = request.GET.get('gender') if location_query != '' and location_query is not None: qs = qs.filter(location__icontains=location_query) elif details_query != '' and details_query is not None: qs = qs.filter(detail__icontains=details_query) elif user_query != '' and user_query is not None: qs = qs.filter(author__icontains=user_query) elif days_query != '' and days_query is not None: qs = qs.filter(no_days__icontains=days_query) elif people_query != '' and people_query is not None: qs = qs.filter(no_people__icontains=people_query) elif date_query != '' and date_query is not None: qs = qs.filter(tour_date__icontains=date_query) elif gender_query != '' and gender_query is not None: qs = qs.filter(Gender_prefer__icontains=gender_query) ########################################################## address = 'Kathmandu' location = geocoder.osm(address) lat = location.lat lng = location.lng country = location.country m = folium.Map(height=500, location=[28, 84], zoom_start=7) folium.Marker([lat, lng], popup=country).add_to(m) m = m._repr_html_() ########################################################## context = { 'qs': qs, 'm': m, } return render(request, 'posts/search.html', context)
def _geocode_addresses(self, addresses: List[str] = None, bing_key: str = None) -> List[Tuple[float, float]]: """ Helper function to geocode a list of addresses Parameters ---------- addresses: list list of all street addresses to be geocoded into latitude and longitude format bing_geocoder: bool If True, Bing's gecoder will be used, else OSM's geocoder is used to geocode street addresses Returns ------- coordinates: list list of all geocoded street addresses """ coordinates = [] counter = 0 for i in range(len(addresses)): counter += 1 print( f"Geocode address {addresses[i]} at {counter}/{len(addresses)}" ) # Apply some sleep to ensure to be below 50 requests per second time.sleep(0.1) address = addresses[i] if bing_key is not None: g = geocoder.bing(address, key=bing_key) else: g = geocoder.osm(address) if g.status == "OK": coords = g.latlng coordinates.append(coords) else: print("status: {}".format(g.status)) coordinates.append(",") return coordinates
def show_map(self, name): """Display the map for a location""" g = geocoder.osm(name) bbox = g.json["bbox"] bbox = bbox["northeast"] + bbox["southwest"] map_ = smopy.Map(bbox, zoom=11) logging.debug("Bounding box: %s", map_.box) ax = map_.show_mpl(figsize=(10, 6)) xs = [] ys = [] # This show all stops on the map, also not the ones # used for processing, but heck . . . lat_ne, lon_ne, lat_sw, lon_sw = bbox stops = (self.session.query(Stop).filter( Stop.stop_lat <= lat_ne, Stop.stop_lat >= lat_sw, Stop.stop_lon <= lon_ne, Stop.stop_lon >= lon_sw, ).all()) for stop in stops: x, y = map_.to_pixels(stop.stop_lat, stop.stop_lon) xs.append(x) ys.append(y) plt.ion() plt.show() ax.plot(xs, ys, ".c") # Plot the tracks in blue for trip in self.trips: shape = trip.shape xys = [ map_.to_pixels(element.shape_pt_lat, element.shape_pt_lon) for element in shape ] xs = [elem[0] for elem in xys] ys = [elem[1] for elem in xys] ax.plot(xs, ys, "-b") plt.pause(0.001) return map_, ax
def checkgeo(self): self._status = False str1 = self.toString() g = geocoder.osm(str1) if g.ok: try: self._status = True self._prediction = g.importance except Exception as e: print(e) else: print('No se ha podido encontrar nada') print(g) return self._status
def geocode(name): url = 'https://maps.googleapis.com/maps/api/geocode/json' params = { 'sensor': 'false', 'address': name, "key": "AIzaSyASk8Wo4ie4CZ4ZjpRRSW0Zq_OZJKP4Xfs" } r = requests.get(url, params=params) try: results = r.json()['results'] location = results[0]['geometry']['location'] name = results[0]["formatted_address"] return (name, (location['lat'], location['lng'])) except: # fallback to open street map if we run out of tokens or something g = geocoder.osm(name) latlng = g.latlng return (name, latlng)
def showLocation(self, selected_ticker_comp: dict) -> None: with st.spinner('Now Loading...'): self.all_location = pd.DataFrame() for comp, ticker in selected_ticker_comp.items(): self.stock_info = yf.Ticker(ticker) self.location = self.stock_info.info["address1"] self.ret = geocoder.osm(self.location, timeout=1.0) self.location = pd.DataFrame(self.ret.latlng) self.location = self.location.T.set_axis(['lat', 'lon'], axis=1) self.all_location = pd.concat( [self.all_location, self.location]) if not self.all_location.empty: st.write("Location Of The Selected Conmanies") st.map(self.all_location)
def mk_json(lang, pattern, place): g = geocoder.osm(place) #print('g=',g.json) tweet = { 'text': pattern.replace('$place', place), 'lang': lang, 'geo': { 'type': 'Point', 'coordinates': [g.latlng[0], g.latlng[1]], }, 'place': { 'place_type': 'city', 'country_code': 'US', 'full_name': place, }, 'timestamp_ms': 1508573111095 } return json.dumps(tweet)
def coords(city_name, country=', Sweden'): """ Returns coordinates according the city name and country. Sweden default Here we trying to get geo coordinates of a city by it's name. Sweden is default as project from where this code is taken , targeting Swedish second hand sail-boat market. Then we store coords in Redis and when we need to get coords for the same place next time - we get it from Redis without requesting OSM(open street maps) geo data provider again. Most likely that place will not change its coords often enough to not keep it coords in cache. """ cache_key = 'coordinates+%s%s' % (city_name, country) coords_from_cache = cache.get(cache_key) if not coords_from_cache: coord_from_osm = geocoder.osm(city_name + country).latlng if coord_from_osm: cache.set(cache_key, coord_from_osm, 60*60*24*30) return coord_from_osm else: return coords_from_cache
def loader(todo): with open('location_geodata.csv', 'a+') as f: i = 0 j = 0 todo_size = len(todo) for loc in todo: time.sleep(5) g = geocoder.osm(loc).latlng if g: loc = loc.replace('"', '""') f.write(f'\n"{loc}",{str(g[0])},{str(g[1])}') f.flush() i += 1 print(i) else: print(f"Failed to load coordinates for address {loc}") j += 1 print(f"{todo_size - j} of {todo_size} left")
def closest_stations(address): # return "Khreshatik" time_to_sleep = 3 # sleep(6) g = geocoder.osm('Ukraine, Kyiv,' + address) if g.lat is None: return "Khreshatik" print('finded location') print(g.lat, g.lng) distances = [{ 'station': metro, 'distance': dist((g.lat, g.lng), coords[metro]) } for metro in coords] distances = sorted(distances, key=lambda el: el['distance']) rez = distances[0]['station'] + ' ' + distances[1][ 'station'] + ' ' + distances[2]['station'] return rez
def insert(self, value): ''' A new thought to be inserted, parses thought input and extracts hashtags, people, reminder and location ''' with shelve.open(self.dbf, writeback=True) as db: thought = value # Get Location location = None if ';' in value: thought, _, location = value.rpartition(';') location = location.strip() g = geocoder.google(location) if g.latlng is None: print('Trying OSM') g = geocoder.osm(location) location = (location, g.latlng) # Prase Recurring event r = RecurringEvent() # read more here https://github.com/kvh/recurrent print(r.parse(thought)) # Colour Hashtags hashtags = {tag for tag in thought.split() if tag.startswith("#")} thought = self.highlight_terms(thought, hashtags, 'ffdc00') # Colour People people = {tag for tag in thought.split() if tag.startswith("@")} thought = self.highlight_terms(thought, people, '7fdbff') # Create People who don't exist for person in people: if person not in db: db[person] = Person(person) # Cleanup value = thought if location: value += '; ' + location # Save Thought to DB db['known_terms'] = list(set(db.get('known_terms', []) + list(hashtags) + list(people))) t = Thought(value, hashtags, people, r, location) db['thoughts'] = db.get('thoughts', []) db['thoughts'].insert(0, t) # Insert into UI self.rv.data.insert(0, {'value': value or 'empty thought'})
def get_health(): """ :return: dictionary with geocoder service health. ::see:: reporter.health. """ try: g = geocoder.osm("New York city", maxRows=1) except (requests.exceptions.RequestException, Exception) as e: # geocoder docs say exception will be raised to the caller time = datetime.now().isoformat() output = "{}".format(e) res = {'status': 'fail', 'time': time, 'output': output} return res else: if g.ok: return {'status': 'pass'} time = datetime.now().isoformat() res = {'status': 'fail', 'time': time, 'output': g.status} return res
def get_hotel(mydict,city): loc2 = geocoder.osm(city) # map main_map = folium.Map(location=[loc2.lat, loc2.lng], zoom_start=13) folium.raster_layers.TileLayer('Open Street Map').add_to(main_map) # loop through dict for i in range (1,len(mydict)+1): folium.Marker(location=list(mydict[i].values())[i-1] ,popup=list(mydict[i].keys())[i-1],tooltip=str(list(mydict[i].keys())[i-1]), icon=plugins.BeautifyIcon(number=i, icon='bus', border_color='blue', border_width=0.5, text_color='red', inner_icon_style='margin-top:0px;')).add_to(main_map) main_map.save('templates/map.html') return render_template('index.html')
def _get_timezone_from_builtins(self, locale): try: # This handles common city names, like "Dallas" or "Paris" # first get the lat / long. g = geocoder.osm(locale) # now look it up tf = TimezoneFinder() timezone = tf.timezone_at(lng=g.lng, lat=g.lat) return pytz.timezone(timezone) except Exception: pass try: # This handles codes like "America/Los_Angeles" return pytz.timezone(locale) except Exception: pass return None
def handle(self): if "WHAT TIME IS IT IN" in transcript: location = transcript[19:] geo = geocoder.osm(location) tzf = TimezoneFinder() timezone = tzf.timezone_at(lng=geo.lng, lat=geo.lat) datetime = datetime.now(timezone) mic.say("THE TIME IN {} IS ".format(transcript[19:]) + datetime.strftime("%H %M")) elif "WHAT TIME IS IT" in transcript: t = time.localtime() current_time = time.strftime("%H %M", t) mic.say("IT IS {}".format(current_time)) if "WHAT IS THE DATE" in transcript: today = date.today() date = today.strftime("%B %d, %Y") mic.say("TODAY IS {}".format(date)) if "TELL ME THE DAY OF THE WEEK" in transcript: today = date.today() mic.say("TODAY IS {}".format(calendar.day_name[today.weekday()])) if "WHAT DAY IS" in transcript: holiday = transcript[12:] year = day.year for date in sorted( holidays.US(years=year).get_named(holiday).items()): mic.say(str(date[0])) break else: mic.say("ERROR FINDING HOLIDAY") if "WHEN IS" in transcript: holiday = transcript[8:] year = day.year for date in sorted( holidays.US(years=year).get_named(holiday).items()): mic.say(str(date[0])) break else: mic.say("ERROR FINDING HOLIDAY")
def get_lat_lng(location): if len(location) > 0: try: g = geocoder.osm(location) debug.info("location is: " + location + " " + str(g.latlng)) except Exception as e: debug.error( "Unable to find {} with Open Street Map, falling back to IP lookup for location. Error: {}" .format(location, e)) g = geocoder.ip('me') debug.info("location is: " + g.city + "," + g.country + " " + str(g.latlng)) else: g = geocoder.ip('me') debug.info("location is: " + g.city + "," + g.country + " " + str(g.latlng)) return g.latlng
def geolocate(address): data = {} location_data = geocoder.osm(address) if location_data.ok: location_data = location_data.json data["raw"] = location_data data["country"] = location_data.get("country") data["country_code"] = location_data.get("country_code") data["region"] = location_data.get("region") data["address"] = location_data.get("address") data["state"] = location_data.get("state") data["confidence"] = location_data.get("confidence") data["lat"] = location_data.get("lat") data["lon"] = location_data.get("lng") data["city"] = location_data.get("city") data["postal"] = location_data.get("postal") data["timezone"] = location_data.get("timezone_short") return data
def get_coordinates(addresses, boroughs): """ Tries to get the coordinates for the given stations. :param addresses: the list of location :param boroughs: the list of boroughs :return: """ latitude = [] longitude = [] for address, borough in zip(addresses, boroughs): try: g = geocoder.osm('{}, {}, New York'.format(address, borough)).json latitude.append(g['lat']) longitude.append(g['lng']) except: latitude.append(None) longitude.append(None) return np.array(latitude).T, np.array(longitude).T
def geocode_osm(self, address): """ Geocode address by OpenStreetMap """ try: # query the time current_time = dt.now() # one request per second if self.time_difference(current_time) < 1: time.sleep(1) # geocode address coder_osm = geocoder.osm(address, maxRows=1) # set new request time self.time = dt.now() if coder_osm.ok: print("Extract coordinates") json = coder_osm.geojson['features'][0]['properties'] # extract information accuracy = json['accuracy'] lat = json['lat'] lng = json['lng'] # convert wgs to etrs x_trans, y_trans = self.wgs2etrs(lng, lat) return self.return_data(accuracy=accuracy, x=x_trans, y=y_trans, source="OSM") else: print("Coder not ok: ", address) return self.return_data() except ConnectionError as e: print("Geocoding ConnectionError: ", e) return self.return_data()
def split_latlon(latlon, address): if latlon == 'None' and address != None: ret = geocoder.osm(address, timeout=5.0) latlon_list = ret.latlng if latlon_list == None: latlon_list = [0.0, 0.0] #もしdmsならdegに変換 if '緯' in latlon: latlon = latlon.replace('北緯', 'l') latlon = latlon.replace('東経', ' l') latlon = latlon.replace('度', 'd') latlon = latlon.replace('分', 'm') latlon = latlon.replace('秒', 's') latlon_list = dms_to_deg(latlon) if len(latlon_list) == 2: return [float(latlon_list[0]), float(latlon_list[1])] else: return 0.0, 0.0
def __pv_system_yield(self, plz, capacity): geocoder_query = '{}, Germany'.format(plz) try: state_full = geocoder.osm(geocoder_query).osm['addr:state'] pv_yield = PvYield.objects.get(state_full=state_full) except: return { 'error_message': 'The postcode you entered does not exist.' } try: capacity_as_int = int(capacity) except: return { 'error_message': 'The capacity value you entered is not a number.' } system_yield = capacity_as_int * pv_yield.spec_yield return {'yield': system_yield, 'state': pv_yield.state}
def get_coords_by_address(addr_str): """ Returns coordinates (lat/lon) of the point with a given address (OSM geocoder is used) Parameters: - addr_str as (str): address of the point Returns: - coords as (tuple): the point's coordinates (lat/lon) - None if the address wasn't recognized """ gcd = geocoder.osm(addr_str) location = gcd.latlng if location is None: logger.error('Address was not recognized...') return None else: coords = tuple(location) return coords
def place_search(query): try: search = geocoder.osm(query)[0].json p = model.Place() p.name = query.strip() p.lat = search['lat'] p.lon = search['lng'] osm_id = str(search['osm_id']) if search['osm_type'] == 'way': osm_id = 'W' + osm_id elif search['osm_type'] == 'node': osm_id = 'N' + osm_id elif search['osm_type'] == 'relation': osm_id = 'R' + osm_id else: print('Unrecognized OSM type', search['osm_type']) p.osm_id = osm_id return p except IndexError: return None # no results
def event(): #print('you have clicked on button') ln = tln.get() ln1 = tln1.get() ln2 = tln2.get() ln4 = tln4.get() ln5 = tln5.get() ln6 = tln6.get() ln7 = tln7.get() ln8= tln8.get() ln9 = tln9.get() ln10= tln10.get() ln_add=ln2+" "+ln4+" "+ln5+" "+ln6 Gender={'Female':0,'Male':1,'Other':2} ln=Gender[ln] Weapon={'Other':0,'Nothing':1,'Knife':2,'Gun':3} ln7=Weapon[ln7] Theft={'Other':0,'Money':1,'Mobile':2,'Jewellery':3,'Bike':4,'Car':5} ln9=Theft[ln9] ToC={'Other':0,'Snaching':1,'Burglary':2,'Robbery':3,'Assault':4,'Extortion':5} ln10=ToC[ln10] import geocoder import geopy from vega_datasets import data as vds address = geocoder.osm(ln_add) #print(address.json) address_latlng = [address.lat, address.lng] fullname1 = [ln,ln1,address.lat, address.lng,ln7,ln8,ln9,ln10] fullname=[] for i in fullname1: fullname.append(i) msg.configure(text="you have clicked on button :") pt.grid_remove() inputbyuser(fullname) return fullname
def test_geocoder(address, method_name='geocoder'): """ geocoder - can use various providers (Google, OSM, etc.) https://geocoder.readthedocs.org/ - can output GeoJSON """ #g_geocoder = geocoder.google(address) g_geocoder = geocoder.osm(address) if g_geocoder.latlng == []: g_geocoder = geocoder.google(address) if g_geocoder.latlng == []: g_geocoder = geocoder.arcgis(address) if g_geocoder.latlng == []: g_geocoder = geocoder.yahoo(address) (latitude, longitude) = g_geocoder.latlng print ('{0}\t{1} {2}'.format(method_name, latitude, longitude)) print(pprint(g_geocoder.geojson))
def top_trends(place="WorldWide"): # Trends for Specific Country g = geocoder.osm( place) # getting object that has location's latitude and longitude closest_loc = api.trends_closest(g.lat, g.lng) # print(closest_loc[0]) # trends = api.trends_place(closest_loc[0]["woeid"]) trends = api.trends_place(1) for ind, value in enumerate(trends[0]["trends"]): if value["tweet_volume"] == None: trends[0]["trends"][ind]["tweet_volume"] = 0 # writing a JSON file that has the latest trends for that location with open("twitter_top_trends.json", "w") as wp: wp.write(json.dumps(trends, indent=1)) return True
def search_around_place(): distance = request.args.get('distance', 500) city = request.args.get('city', 'arlington') usr_g_json = geocoder.osm(city).json trgt_coords = (usr_g_json['lat'], usr_g_json['lng']) db2conn = ibm_db.connect(db2cred['ssldsn'], "", "") if db2conn: sql = "SELECT * FROM EARTHQUAKE" stmt = ibm_db.exec_immediate(db2conn, sql) rows = [] result = ibm_db.fetch_assoc(stmt) while result != False: curr_coords = (result['LATITUDE'], result['LONGTITUDE']) if geopy.distance.vincenty(curr_coords, trgt_coords).km < distance: rows.append(result.copy()) result = ibm_db.fetch_assoc(stmt) ibm_db.close(db2conn) return render_template('search_around_place.html', ci=rows)
def geocode(location, provider='google', display_map=False): # Try to find the location 10 times before raising the warning and returning coordinates (0.0, 0.0) i = 0 while True: if provider == 'google': geo = geocoder.google(location) elif provider == 'nokia': geo = geocoder.nokia(location) elif provider == 'osm': geo = geocoder.osm(location) elif provider == 'bing': geo = geocoder.bing(location) elif provider == 'tomtom': geo = geocoder.tomtom(location) if geo.json['status'] == 'OK' or i == 10: break i+=1 #print geo.json if display_map == True: #Check if address is a coordinate pair if location.replace(',', '').replace('.', '').replace('-', '').isdigit(): url = "http://maps.google.com/?q=%s" % geo.address else: url = "http://www.google.com/maps/place/%s,%s" % (geo.lat, geo.lng) webbrowser.open(url) if geo.json['status'] == 'OK': #time.sleep(0.5) # Try to avoid the rate limit return geo.json else: warn = 'WARNING: %s was not found! Coordinates (0.0, 0.0) was returned instead.' % location warnings.warn(warn) #time.sleep(0.5) # Try to avoid the rate limit return {'lat': 0.0, 'lng': 0.0}
def remove_address(address, output=CITIES_FILENAME): logger.info('Querying the server for: "%s" ...', address) response = geocoder.osm(address) logger.info('Got an answer!') logger.info('Place: %s', response.address) logger.info('Loading old cities from: %s', output) cities = load_json(output) removed = False next_cities = cities['next'] for city in next_cities: if city['osm_id'] == response.json['osm_id']: logger.info('City: %s removed!', city['address']) next_cities.remove(city) removed = True break if removed: save_json(cities, output) else: logger.info('City not found!') return response
def get_place_bound_box(cls, place): print place boundBox = None try: #print place g = geocoder.osm(place) box = g.bbox #print box swlat = box["southwest"][0] swlon = box["southwest"][1] nelat = box["northeast"][0] nelon = box["northeast"][1] #print swlat, swlon, nelat, nelon boundBox = GeoBoundBox(swlat, swlon, nelat, nelon) except: InOut.except_info("get_place_bound_box") boundBox = None return boundBox
def get_coordinates(self, address): """ Using geocoder to decode address - can use various providers (Google, OSM, etc.) https://geocoder.readthedocs.org/ - can output GeoJSON - proxies from http://www.proxy-listen.de/Proxy/Proxyliste.html """ #proxies = {'149.202.249.227:3128', '144.76.232.58:3128'} #g_geocoder = geocoder.osm(address, proxies=proxies) g_geocoder = geocoder.osm(address) # in case OSM didn't provide anything use Google Maps if g_geocoder.latlng == []: g_geocoder = geocoder.google(address) # in case Google Maps didn't provide anything use ArcGIS if g_geocoder.latlng == []: g_geocoder = geocoder.arcgis(address) (latitude, longitude) = g_geocoder.latlng if DEBUG: print ('[i] location : {0} {1}'.format(latitude, longitude)) return {'lat': latitude, 'lng': longitude}
def test_repr_unicode(): g = geocoder.osm('Tokyo, Japan') assert g
def test_osm_reverse(): g = geocoder.osm(ottawa, method='reverse') assert g.ok
print g print "looking at ", dictedinput['Address'] + "," + dictedinput['City'] + "," + dictedinput['State'] + "," + dictedinput['Zip Code'] if g.lat and g.lng: tempoutput.append(row + [g.lat, g.lng]) successdict['success'] += 1 if DEBUG: print g.lat, g.lng else: g = geocoder.google(dictedinput['Address'] + "," + dictedinput['City'] + "," + dictedinput['State'] + "," + dictedinput['Zip Code']) if g.lat and g.lng: tempoutput.append(row + [g.lat, g.lng]) successdict['success'] += 1 if DEBUG: print g.lat, g.lng else: g = geocoder.osm(dictedinput['Address'] + "," + dictedinput['City'] + "," + dictedinput['State'] + "," + dictedinput['Zip Code']) if g.lat and g.lng: tempoutput.append(row + [g.lat, g.lng]) successdict['success'] += 1 if DEBUG: print g.lat, g.lng else: successdict['fails'] += 1 print "there was an error with", dictedinput['Address'] + "," + dictedinput['City'] + "," + dictedinput['State'] + "," + dictedinput['Zip Code'] tempoutput.append(row + ["x", "x"]) # if DEBUG: # if counter > LIMIT: # break print "Success:", successdict['success'] print "Fails:", successdict['fails']
def getosm(**kwargs): """ get osm region from osmapi Parameters ---------- address : string latlon : tuple or 0 dist_m : float bcart : boolean level_height : float typical level height for deriving building height from # levels typical_height : float typical height for building when no information Returns ------- coords nodes ways dpoly m latlon : tuple or 0 Notes ----- There are 3 ways to read an Open Street Map structure 1 - From an osm file ex : filename = 'B11.osm' 2 - From an osm (lat,lon) string or tuple of float 3 - From an osm address string if latlon tuple is precised, it has priority over the address string """ filename = kwargs.pop('filename','') bcart = kwargs.pop('cart', False) typ = kwargs.pop('typ','indoor') level_height = kwargs.pop('level_height', 3.45) typical_height = kwargs.pop('typical_height', 10) # from coordinates if filename == '': address = kwargs.pop('address','Rennes') latlon = kwargs.pop('latlon', 0) dist_m = kwargs.pop('dist_m', 400) rad_to_deg = (180/np.pi) if latlon == 0: place = geo.osm(address) try: lat, lon = place.latlng except: print(place) else: lat = latlon[0] lon = latlon[1] r_earth = 6370e3 alpha = (dist_m/r_earth)*rad_to_deg # # get map from OsmApi (Database query) # same extension in longitude and latitude # Osm = OsmApi() osmmap = Osm.Map(lon-alpha, lat-alpha, lon+alpha, lat+alpha) else: # # get map from osm (xml) file # type : 'node' # 'ways' # latlon = 0 e = xml.parse(filename).getroot() osmmap = [] lnode_key = ['id', 'lat', 'lon'] lway_key = ['id'] for i in e: d = {} d['type'] = i.tag d['data'] = i.attrib #print(i.tag) if d['type'] == 'node': for k in lnode_key: try: d['data'][k] = eval(d['data'][k]) except: pass if k == 'id': if not 'action' in d['data']: d['data'][k] = -d['data'][k] d['data']['tag'] = {} elif d['type'] == 'way': lk = i.getchildren() nd = [] tag = {} for k in lk: if k.tag == 'nd': nd.append(eval(k.get('ref'))) if k.tag == 'tag': tag[k.get('k')] = k.get('v') d['data']['nd'] = nd d['data']['tag'] = tag # for k in lway_key: # lk = k.get_children() # print(lk) # d['data'][k]=eval(d['data'][k]) # d['data']['visible']=eval(d['data']['visible']) osmmap.append(d) nodes = Nodes() nodes.clean() nodes.readmap(osmmap) coords = Coords() coords.clean() coords.from_nodes(nodes) m = coords.cartesian(cart=bcart) ways = Ways() ways.clean() lat = coords.latlon[list(coords.latlon.keys())[0]][0] lon = coords.latlon[list(coords.latlon.keys())[0]][1] if typ == 'indoor': ways.readmap1(osmmap, coords) else: ltree = ways.readmap2(osmmap, coords) # list of nodes involved in buildings lnodes_id=[] for iw in ways.w: lnodes_id += ways.w[iw][0] # list of all nodes of coords lnodes_id = np.unique(np.array(lnodes_id)) lnodes_full = np.unique(np.array(list(coords.latlon.keys()))) mask = np.in1d(lnodes_full, lnodes_id, invert=True) # nodes not involved in buildings #if typ != 'indoor': # lexcluded = lnodes_full[mask] # coords.filter(lexcluded) # dpoly = {} # for iw in ways.w: # # ways.way[iw].tags = {} # # # material # # if 'material' in ways.w[iw][1]: # # ways.way[iw].tags['name']=ways.w[iw][1]['material'] # # elif 'building:material' in ways.w[iw][1]: # # ways.way[iw].tags['name']=ways.w[iw][1]['building:material'] # # else: # # ways.way[iw].tags['name']='WALL' # # # min_height # # if 'building:min_height' in ways.w[iw][1]: # # min_height = eval(ways.w[iw][1]['building:min_height']) # # else: # # min_height = 0 # # # height # # if 'height' in ways.w[iw][1]: # # ways.way[iw].tags['z'] = (min_height, eval(ways.w[iw][1]['height'])) # # elif 'building:height' in ways.w[iw][1]: # # ways.way[iw].tags['z'] = (min_height, eval(ways.w[iw][1]['building:height'])) # # elif 'building:levels' in ways.w[iw][1]: # # nb_levels = eval(ways.w[iw][1]['building:levels']) # # if type(nb_levels)!=int: # # try: # # nb_levels = max(nb_levels) # # except: # # nb_levels=2 # # ways.way[iw].tags['z']=(min_height,nb_levels*level_height) # # elif 'levels' in ways.w[iw][1]: # # nb_levels = eval(ways.w[iw][1]['levels']) # # if type(nb_levels)!=int: # # try: # # nb_levels=max(nb_levels) # # except: # # nb_levels=2 # # ways.way[iw].tags['z'] = (min_height,nb_levels*level_height) # # else: # # ways.way[iw].tags['z'] = (0,typical_height) # ptpoly = [coords.xy[x] for x in ways.w[iw][0]] # dpoly[iw] = geu.Polygon(ptpoly,vnodes=ways.w[iw][0]) # dpoly[iw].coorddeter() #return coords,nodes,ways,dpoly,m return coords, nodes, ways, m, (lat,lon)
def test_osm(): g = geocoder.osm(location) assert g.ok assert g.city == city
for item in db_city.find().skip(22000).limit(50000): if not item['location'] in existing: search.append(item) print 'Remaining:', len(search) # Scan Database for item in search: location = item['location'] x, y = item['geometry']['coordinates'] # Geocode Address if provider == 'bing': g = geocoder.bing(location) elif provider == 'osm': time.sleep(1) g = geocoder.osm(location) # Calculate Distance with Haversine formula distance = haversine([y, x], [g.lat, g.lng]) * 1000 # Set Results results = g.json results['city'] = city results['distance'] = distance # Save in Mongo DB try: db_geocoder.insert(results) except: print 'Duplicate'
def address_to_coordinates(user_address): the_location = geocoder.osm(user_address) lat = the_location.osm.get('y',None) lon = the_location.osm.get('x', None) return (lat,lon)
def view_particular_event(event_name): #Sets the event value to not past past = False #Gets the name of the user logged in user_in_use = g.user #Gets the user's events events = db.events.find({'who_made_me':g.user}) my_events = [] for i in events: my_events.append(i['name']) #If logged in if g.user: #Check if past_event: if db.events.find_one({'name':event_name}) != None: event = db.events.find_one({'name': event_name}) elif db.past_events.find_one({'name':event_name}) != None: event = db.past_events.find_one({'name':event_name}) past = True #querying the map from OSM API. It takes the Address of the location as OSM search and spits out a lat and lng var = event geocode = geocoder.osm(var['address']) lat_of_event = geocode.json["lat"] lng_of_event = geocode.json["lng"] #Real time search for users that are attending the event, will be implemented for events also results = [] search_results = None search_term = None if request.method == 'POST' : search_term = request.json['search'] search_results = db.users.find({'going_to':var['name'], 'name':{'$regex': search_term}}) for i in search_results: results.append(i['name']) print results return jsonify(results=results) return render_template('one_event.html', var=var,my_events=my_events,user_in_use =user_in_use,lat=lat_of_event,lng=lng_of_event,search_results=search_results,past=past,results=results) else: return redirect(url_for('login'))
def test_multi_results(): g = geocoder.osm(location, maxRows='5') assert len(g) == 5
''' Created on 09-23-2015 @author: Wuga ''' import folium import geocoder import DataOperation as DO import DataPreprocess as DP import Vorplots as V import Constants import pandas as pd g=geocoder.osm('dublin,ireland') loca=g.latlng print loca LOCATION=Constants.filelocations.DUBLIN_2010 df=DO.readgeofile(LOCATION) train,test,train_index,test_index=DO.dataseperator(df) map_osm = folium.Map(location=loca, zoom_start=9, max_zoom=18) train=DP.elim(train) train = train.reset_index(drop=True) V.voronoiplot(DP.elim(train)) map_osm.geo_json(geo_path=r'autovoronoi.json', data_out='/Users/Wuga/Documents/DATA/SFREHPDATA/pricedata.json',data=pd.read_csv('/Users/Wuga/Documents/DATA/SFREHPDATA/pricedata.csv'),columns=['Id','Price'],key_on='feature.id', threshold_scale=[200000,250000,300000,350000,400000,500000], fill_color='YlOrRd', fill_opacity=0.5, line_opacity=0.5, legend_name='SF house price') map_osm.create_map(path=Constants.filelocations.MAP_HTML)
hpdr = requests.get(url_hpd, params=parms) print('request complete, now reading json...') hpdf=pd.read_json(hpdr.text, dtype={'zip': 'str'}) hpdf['address'] = hpdf.housenumber+' '+ hpdf.streetname + ', ' + city+', NEW YORK'# hpdf.boro + ', ' + hpdf.zip hpdf.dropna() #url_geo = 'https://maps.googleapis.com/maps/api/geocode/json' longlist = [] latlist = [] pause = 5 for i,row in hpdf.iterrows():#_using.iterrows(): #geops = {'sensor': 'false', 'address': row['address'], 'key': API_KEY_GEO} #geor = requests.get(url_geo, params=geops) #georesponse = geor.json()#['results'] #print(row['address']) try: g = geocoder.osm(row['address']) except TypeError as e: print('TypeError:') print(e) print('lets pause for %d seconds..' % pause) time.sleep(pause) pause += 5 pass except: print('problem in getting osm response') time.sleep(pause) pause += 1 pass #print(g.osm) if g.osm: #hpdf['long'][i] = g.osm["x"]
def test_detailed_query(): g = geocoder.osm("",postalcode="45326", street="Ellernstraße", method="details") assert g.postal == "45326" assert "ellern" in g.street.lower() assert g.ok
def test_osm(): g = geocoder.osm(location) assert g.ok osm_count, fields_count = g.debug()[0] assert osm_count >= 3 assert fields_count >= 21
import geocoder import requests # Geocode Address from the OSM server # Website: https://github.com/DenisCarriere/geocoder g = geocoder.osm("Westboro, Ottawa ON") # Define Bounding Box query for Overpass bbox = '<bbox-query s="{south}" w="{west}" n="{north}" e="{east}"/>'.format(south=g.south, west=g.west, north=g.north, east=g.east) # Define which keys & values you want to extract with your Overpass request # Website: http://overpass-turbo.eu/ has_kv = """ <has-kv k="amenity" v="cafe"/> <has-kv k="cuisine" v="coffee_shop"/> """ # Standard XML format for the Overpass query data = """ <osm-script output="json" timeout="25"> <union> <query type="node"> {has_kv} {bbox} </query> <query type="way"> {has_kv} {bbox} </query> </union> <print mode="body"/>