# The code was removed by Watson Studio for sharing.
# place to create data sets for neighborhood
# Richmond Circle Under Fly Over, Bengaluru, Karnataka, 

google_api_key='AIzaSefcBBchangedmqxX1a41u4forsecuritylPlVreasomnsGs'

import requests

def get_coordinates(api_key, address, verbose=False):
    try:
        url = 'https://maps.googleapis.com/maps/api/geocode/json?key={}&address={}'.format(api_key, address)
        response = requests.get(url).json()
        if verbose:
            print('Google Maps API JSON result =>', response)
        results = response['results']
        geographical_data = results[0]['geometry']['location'] # get geographical coordinates
        lat = geographical_data['lat']
        lon = geographical_data['lng']
        return [lat, lon]
    except:
        return [None, None]
    
address = 'Richmond Circle Under Fly Over, Bengaluru, Karnataka'
richmond_circle = get_coordinates(google_api_key, address)
print('Coordinate of {}: {}'.format(address, richmond_circle))

#!pip install shapely
import shapely.geometry

#!pip install pyproj
import pyproj

import math

def lonlat_to_xy(lon, lat):
    proj_latlon = pyproj.Proj(proj='latlong',datum='WGS84')
    proj_xy = pyproj.Proj(proj="utm", zone=33, datum='WGS84')
    xy = pyproj.transform(proj_latlon, proj_xy, lon, lat)
    return xy[0], xy[1]

def xy_to_lonlat(x, y):
    proj_latlon = pyproj.Proj(proj='latlong',datum='WGS84')
    proj_xy = pyproj.Proj(proj="utm", zone=33, datum='WGS84')
    lonlat = pyproj.transform(proj_xy, proj_latlon, x, y)
    return lonlat[0], lonlat[1]

def calc_xy_distance(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    return math.sqrt(dx*dx + dy*dy)

print('Coordinate transformation check')
print('-------------------------------')
print('Richmond Circle longitude={}, latitude={}'.format(richmond_circle[1], richmond_circle[0]))
x, y = lonlat_to_xy(richmond_circle[1], richmond_circle[0])
print('Richmond Circle UTM X={}, Y={}'.format(x, y))
lo, la = xy_to_lonlat(x, y)
print('Richmond Circle longitude={}, latitude={}'.format(lo, la))

richmond_circle_x, richmond_circle_y = lonlat_to_xy(richmond_circle[1], richmond_circle[0]) # City center in Cartesian coordinates

k = math.sqrt(3) / 2 # Vertical offset for hexagonal grid cells
x_min = richmond_circle_x - 3000
x_step = 600
y_min = richmond_circle_y - 3000 - (int(21/k)*k*600 - 12000)/2
y_step = 600 * k 

latitudes = []
longitudes = []
distances_from_center = []
xs = []
ys = []
for i in range(0, int(21/k)):
    y = y_min + i * y_step
    x_offset = 300 if i%2==0 else 0
    for j in range(0, 21):
        x = x_min + j * x_step + x_offset
        distance_from_center = calc_xy_distance(richmond_circle_x, richmond_circle_y, x, y)
        if (distance_from_center <= 6001):
            lon, lat = xy_to_lonlat(x, y)
            latitudes.append(lat)
            longitudes.append(lon)
            distances_from_center.append(distance_from_center)
            xs.append(x)
            ys.append(y)

print(len(latitudes), 'candidate neighborhood centers generated.')

#!pip install folium

import folium

map_richmond = folium.Map(location=richmond_circle, zoom_start=13)
folium.Marker(richmond_circle, popup='Richmond Circle').add_to(map_richmond)
for lat, lon in zip(latitudes, longitudes):
    #folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond) 
    folium.Circle([lat, lon], radius=300, color='blue', fill=False).add_to(map_richmond)
    #folium.Marker([lat, lon]).add_to(map_richmond)
map_richmond

def get_address(api_key, latitude, longitude, verbose=False):
    try:
        url = 'https://maps.googleapis.com/maps/api/geocode/json?key={}&latlng={},{}'.format(api_key, latitude, longitude)
        response = requests.get(url).json()
        if verbose:
            print('Google Maps API JSON result =>', response)
        results = response['results']
        address = results[0]['formatted_address']
        return address
    except:
        return None

addr = get_address(google_api_key, richmond_circle[0], richmond_circle[1])
print('Reverse geocoding check')
print('-----------------------')
print('Address of [{}, {}] is: {}'.format(richmond_circle[0], richmond_circle[1], addr))

print('Obtaining location addresses: ', end='')
addresses = []
for lat, lon in zip(latitudes, longitudes):
    address = get_address(google_api_key, lat, lon)
    if address is None:
        address = 'NO ADDRESS'
    address = address.replace(', India', '') # We don't need country part of address
    addresses.append(address)
    print(' .', end='')
print(' done.')

addresses[150:170]

import pandas as pd

df_locations = pd.DataFrame({'Address': addresses,
                             'Latitude': latitudes,
                             'Longitude': longitudes,
                             'X': xs,
                             'Y': ys,
                             'Distance from center': distances_from_center})

df_locations.head(10)

df_locations.to_pickle('./locations.pkl')    

# The code was removed by Watson Studio for sharing.
foursquare_client_id, foursquare_client_secret='154JNGBAO4somethingS15NUS5HchangedCTHORGJMWKOF','3B0JXThisCLFKNZGGME4MalsoZCA0changed2LST3KCKKC'

# Category IDs corresponding to Italian breakfast spots were taken from Foursquare web site (https://developer.foursquare.com/docs/resources/categories):

food_category = '4d4b7105d754a06374d81259' # 'Root' category for all food-related venues

def is_restaurant(categories, specific_filter=None):
    restaurant_words = ['restaurant', 'diner', 'taverna', 'steakhouse']
    restaurant = False
    specific = False
    for c in categories:
        category_name = c[0].lower()
        category_id = c[1]
        for r in restaurant_words:
            if r in category_name:
                restaurant = True
        if 'fast food' in category_name:
            restaurant = False
        if not(specific_filter is None) and (category_id in specific_filter):
            specific = True
            restaurant = True
    return restaurant, specific

def get_categories(categories):
    return [(cat['name'], cat['id']) for cat in categories]

def format_address(location):
    address = ', '.join(location['formattedAddress'])
    address = address.replace(', India', '')
    return address

def get_venues_near_location(lat, lon, category, client_id, client_secret, radius=500, limit=100):
    version = '20180724'
    url = 'https://api.foursquare.com/v2/venues/explore?client_id={}&client_secret={}&v={}&ll={},{}&categoryId={}&radius={}&limit={}'.format(
        client_id, client_secret, version, lat, lon, category, radius, limit)
    try:
        results = requests.get(url).json()['response']['groups'][0]['items']
        venues = [(item['venue']['id'],
                   item['venue']['name'],
                   get_categories(item['venue']['categories']),
                   (item['venue']['location']['lat'], item['venue']['location']['lng']),
                   format_address(item['venue']['location']),
                   item['venue']['location']['distance']) for item in results]        
    except:
        venues = []
    return venues

# Try getting venues as any one category to test the get_venues_near_any_location function
venues = get_venues_near_location(richmond_circle[0], richmond_circle[1], '4bf58dd8d48988d143941735', foursquare_client_id, foursquare_client_secret, radius=350, limit=100)
len(venues)

# Let's now go over our neighborhood locations and get nearby breakfast spots; we'll also maintain a dictionary of all found breakfast spots.

import pickle


def get_venues(lats, lons, category_id):
    allvenues={}
    location_venues=[]
    
    print('Obtaining venues around candidate locations:', end='')
    for lat, lon in zip(lats, lons):
        # Using radius=350 to meke sure we have overlaps/full coverage so we don't miss any restaurant (we're using dictionaries to remove any duplicates resulting from area overlaps)
        venues = get_venues_near_location(lat, lon, category_id, foursquare_client_id, foursquare_client_secret, radius=350, limit=100)
        area_venues = []
        for venue in venues:
            venue_id = venue[0]
            venue_name = venue[1]
            venue_categories = venue[2]
            venue_latlon = venue[3]
            venue_address = venue[4]
            venue_distance = venue[5]
            #is_res, is_italian = is_restaurant(venue_categories, specific_filter=italian_restaurant_categories)
            
            #if is_res:
            x, y = lonlat_to_xy(venue_latlon[1], venue_latlon[0])
            venue_detail = (venue_id, venue_name, venue_latlon[0], venue_latlon[1], venue_address, venue_distance, x, y)
            if venue_distance<=300:
                area_venues.append(venue_detail)
                
            allvenues[venue_id] = venue_detail
                
        location_venues.append(area_venues)
        
        print(' .', end='')
    print(' done.')
    
    return allvenues, location_venues

# Try to load from local file system in case we did this before

night_life_category='4d4b7105d754a06376d81259'
night_life_venues={}
location_night_lives=[]
night_life_file_name='night_life.pkl'

shop_n_service_category='4d4b7105d754a06378d81259'
shop_n_service_venues={}
location_shop_n_service=[]
shop_n_service_file_name='shop_n_service.pkl'

breakfast_spot_category='4bf58dd8d48988d143941735'
breakfast_spots={}
location_breakfast_stops=[]
breakfast_spot_file_name='breakfast_spot.pkl'


venue_categories=[night_life_file_name, shop_n_service_file_name, breakfast_spot_file_name]

for venue_category in venue_categories:

    loaded = False
    
    if 'night_life' in venue_category:
        
        try:

            with open(night_life_file_name, 'rb') as f:
                night_life_venues = pickle.load(f)
            
            with open('location_'+night_life_file_name, 'rb') as f:
                location_night_lives = pickle.load(f)
                
            print('Nightlife spots data loaded.')
            loaded = True
        except:
            pass

        # If load failed use the Foursquare API to get the data
        if not loaded:
            night_life_venues, location_night_lives = get_venues(latitudes, longitudes, night_life_category)

            # Let's persists this in local file system
            with open(night_life_file_name, 'wb') as f:
                pickle.dump(night_life_venues, f)
            
            with open('location_'+night_life_file_name, 'wb') as f:
                pickle.dump(location_night_lives, f)
                
            print('Nightlife spots data obtained.')
                
    elif 'shop_n_service' in venue_category:
        
        try:

            with open(shop_n_service_file_name, 'rb') as f:
                shop_n_service_venues = pickle.load(f)
            
            with open('location_'+shop_n_service_file_name, 'rb') as f:
                location_shop_n_service = pickle.load(f)
                
            print('Shop and Service spots data loaded.')
            loaded = True
        except:
            pass

        # If load failed use the Foursquare API to get the data
        if not loaded:
            shop_n_service_venues, location_shop_n_service = get_venues(latitudes, longitudes, shop_n_service_category)

            # Let's persists this in local file system
            with open(shop_n_service_file_name, 'wb') as f:
                pickle.dump(shop_n_service_venues, f)
            
            with open('location_'+shop_n_service_file_name, 'wb') as f:
                pickle.dump(shop_n_service_venues, f)
            
            print('Shop and Service spots data obtained.')
                
    elif 'breakfast_spot' in venue_category:
        
        try:

            with open(breakfast_spot_file_name, 'rb') as f:
                breakfast_spots = pickle.load(f)
            
            with open('location_'+breakfast_spot_file_name, 'rb') as f:
                location_breakfast_stops = pickle.load(f)
                
            print('Breakfast spots data loaded.')
            loaded = True
        except:
            pass

        # If load failed use the Foursquare API to get the data
        if not loaded:
            breakfast_spots, location_breakfast_stops = get_venues(latitudes, longitudes, breakfast_spot_category)

            # Let's persists this in local file system
            with open(breakfast_spot_file_name, 'wb') as f:
                pickle.dump(breakfast_spots, f)
            
            with open('location_'+night_life_file_name, 'wb') as f:
                pickle.dump(location_breakfast_stops, f)
            
            print('Breakfast spots data obtained.')

import numpy as np

print('Total number of Night Life spots:', len(night_life_venues))
print('Average number of night life spots in neighborhood:', np.array([len(r) for r in location_night_lives]).mean())

print('Total number of Shop and Service venues:', len(shop_n_service_venues))
print('Average number of  Shop and Service venues in neighborhood:', np.array([len(r) for r in location_shop_n_service]).mean())

print('Total number of breakfast spots:', len(breakfast_spots))
print('Average number of breakfast spots in neighborhood:', np.array([len(r) for r in location_breakfast_stops]).mean())

print('-----------------------')
print('List of all night life spots')
print('-----------------------')
for r in list(night_life_venues.values())[:10]:
    print(r)
print('...')
print('Total:', len(night_life_venues))

print('-----------------------')
print('List of all shop n service  spots')
print('-----------------------')
for r in list(shop_n_service_venues.values())[:10]:
    print(r)
print('...')
print('Total:', len(shop_n_service_venues))

print('-----------------------')
print('List of all breakfast spots')
print('-----------------------')
for r in list(breakfast_spots.values())[:10]:
    print(r)
print('...')
print('Total:', len(breakfast_spots))

location_night_lives_count = [len(res) for res in location_night_lives]
location_shop_n_service_count = [len(res) for res in location_shop_n_service]
location_breakfast_stops_count = [len(res) for res in location_breakfast_stops]

df_locations['Night_Life_Spots_In_Area'] = location_night_lives_count
df_locations['Shop_N_Service_Spots_In_Area'] = location_shop_n_service_count
df_locations['Breakfast_Spots_In_Area'] = location_breakfast_stops_count

print('Average number of Night Life spots in every area with radius=300m:', np.array(location_night_lives_count).mean())
print('Average number of Shop and Service spots in every area with radius=300m:', np.array(location_shop_n_service_count).mean())
print('Average number of Breakfast spots in every area with radius=300m:', np.array(location_breakfast_stops_count).mean())

df_locations.head(10)

distances_to_breakfast_spots= []

for area_x, area_y in zip(xs, ys):
    min_distance = 10000
    for res in breakfast_spots.values():
        res_x = res[6]
        res_y = res[7]
        d = calc_xy_distance(area_x, area_y, res_x, res_y)
        if d<min_distance:
            min_distance = d
    distances_to_breakfast_spots.append(min_distance)

df_locations['Distance_to_Breakfast_spots'] = distances_to_breakfast_spots

df_locations.head(10)

print('Average distance to closest Breakfast spot from each area center:', df_locations['Distance_to_Breakfast_spots'].mean())

richmond_boroughs_url = 'https://raw.githubusercontent.com/stupidnetizen/Coursera_Capstone/master/richmond_circle_area.geojson'
import json
# Download from the above URL and load the geojson file
with open('richmond_circle_area.geojson', 'r') as f:
    richmond_boroughs = json.load(f)

def boroughs_style(feature):
    return { 'color': 'blue', 'fill': False }

night_life_spots_latlons = [[res[2], res[3]] for res in night_life_venues.values()]

breakfast_spots_latlons = [[res[2], res[3]] for res in breakfast_spots.values()]

import folium
from folium import plugins
from folium.plugins import HeatMap

map_richmond = folium.Map(location=richmond_circle, zoom_start=13)
folium.TileLayer('cartodbpositron').add_to(map_richmond) #cartodbpositron cartodbdark_matter
HeatMap(night_life_spots_latlons).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
folium.Circle(richmond_circle, radius=1000, fill=False, color='white').add_to(map_richmond)
folium.Circle(richmond_circle, radius=2000, fill=False, color='white').add_to(map_richmond)
folium.Circle(richmond_circle, radius=3000, fill=False, color='white').add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

map_richmond = folium.Map(location=richmond_circle, zoom_start=13)
folium.TileLayer('cartodbpositron').add_to(map_richmond) #cartodbpositron cartodbdark_matter
HeatMap(breakfast_spots_latlons).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
folium.Circle(richmond_circle, radius=1000, fill=False, color='white').add_to(map_richmond)
folium.Circle(richmond_circle, radius=2000, fill=False, color='white').add_to(map_richmond)
folium.Circle(richmond_circle, radius=3000, fill=False, color='white').add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

roi_x_min = richmond_circle_x - 2000
roi_y_max = richmond_circle_y + 1000
roi_width = 5000
roi_height = 5000
roi_center_x = roi_x_min + 2500
roi_center_y = roi_y_max - 2500
roi_center_lon, roi_center_lat = xy_to_lonlat(roi_center_x, roi_center_y)
roi_center = [roi_center_lat, roi_center_lon]

map_richmond = folium.Map(location=roi_center, zoom_start=14)
HeatMap(breakfast_spots_latlons).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
folium.Circle(roi_center, radius=2500, color='white', fill=True, fill_opacity=0.4).add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

k = math.sqrt(3) / 2 # Vertical offset for hexagonal grid cells
x_step = 100
y_step = 100 * k 
roi_y_min = roi_center_y - 2500

roi_latitudes = []
roi_longitudes = []
roi_xs = []
roi_ys = []
for i in range(0, int(51/k)):
    y = roi_y_min + i * y_step
    x_offset = 50 if i%2==0 else 0
    for j in range(0, 51):
        x = roi_x_min + j * x_step + x_offset
        d = calc_xy_distance(roi_center_x, roi_center_y, x, y)
        if (d <= 2501):
            lon, lat = xy_to_lonlat(x, y)
            roi_latitudes.append(lat)
            roi_longitudes.append(lon)
            roi_xs.append(x)
            roi_ys.append(y)

print(len(roi_latitudes), 'candidate neighborhood centers generated.')

def count_breakfast_spots_nearby(x, y, breakfast_spots, radius=250):    
    count = 0
    for res in breakfast_spots.values():
        res_x = res[6]; res_y = res[7]
        d = calc_xy_distance(x, y, res_x, res_y)
        if d<=radius:
            count += 1
    return count

def find_nearest_breakfast_spot(x, y, breakfast_spots):
    d_min = 100000
    for res in breakfast_spots.values():
        res_x = res[6]; res_y = res[7]
        d = calc_xy_distance(x, y, res_x, res_y)
        if d<=d_min:
            d_min = d
    return d_min

roi_breakfast_spots_counts = []
roi_breakfast_distances = []

print('Generating data on location candidates... ', end='')
for x, y in zip(roi_xs, roi_ys):
    count = count_breakfast_spots_nearby(x, y, breakfast_spots, radius=250)
    roi_breakfast_spots_counts.append(count)
    distance = find_nearest_breakfast_spot(x, y, breakfast_spots)
    roi_breakfast_distances.append(distance)
print('done.')

good_res_count = np.array((df_roi_locations['Breakfast spots nearby']<=2))
print('Locations with no more than two Breakfast spots nearby:', good_res_count.sum())

good_ita_distance = np.array(df_roi_locations['Distance to breakfast spot']>=400)
print('Locations with no breakfast_spot  within 400m:', good_ita_distance.sum())

good_locations = np.logical_and(good_res_count, good_ita_distance)
print('Locations with both conditions met:', good_locations.sum())

df_good_locations = df_roi_locations[good_locations]

good_latitudes = df_good_locations['Latitude'].values
good_longitudes = df_good_locations['Longitude'].values

good_locations = [[lat, lon] for lat, lon in zip(good_latitudes, good_longitudes)]

map_richmond = folium.Map(location=roi_center, zoom_start=14)
folium.TileLayer('cartodbpositron').add_to(map_richmond)
HeatMap(breakfast_spots_latlons).add_to(map_richmond)
folium.Circle(roi_center, radius=2500, color='white', fill=True, fill_opacity=0.6).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond) 
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

map_richmond = folium.Map(location=roi_center, zoom_start=14)
HeatMap(good_locations, radius=25).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

from sklearn.cluster import KMeans

number_of_clusters = 15

good_xys = df_good_locations[['X', 'Y']].values
kmeans = KMeans(n_clusters=number_of_clusters, random_state=0).fit(good_xys)

cluster_centers = [xy_to_lonlat(cc[0], cc[1]) for cc in kmeans.cluster_centers_]

map_richmond = folium.Map(location=roi_center, zoom_start=14)
folium.TileLayer('cartodbpositron').add_to(map_richmond)
HeatMap(breakfast_spots_latlons).add_to(map_richmond)
folium.Circle(roi_center, radius=2500, color='white', fill=True, fill_opacity=0.4).add_to(map_richmond)
folium.Marker(richmond_circle).add_to(map_richmond)
for lon, lat in cluster_centers:
    folium.Circle([lat, lon], radius=500, color='green', fill=True, fill_opacity=0.25).add_to(map_richmond) 
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

map_richmond = folium.Map(location=roi_center, zoom_start=14)
folium.Marker(richmond_circle).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.Circle([lat, lon], radius=250, color='#00000000', fill=True, fill_color='#0066ff', fill_opacity=0.07).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond)
for lon, lat in cluster_centers:
    folium.Circle([lat, lon], radius=500, color='green', fill=False).add_to(map_richmond) 
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

map_richmond = folium.Map(location=richmond_circle, zoom_start=15)
folium.Marker(richmond_circle).add_to(map_richmond)
for lon, lat in cluster_centers:
    folium.Circle([lat, lon], radius=500, color='green', fill=False).add_to(map_richmond) 
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.Circle([lat, lon], radius=250, color='#0000ff00', fill=True, fill_color='#0066ff', fill_opacity=0.07).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

map_richmond = folium.Map(location=richmond_circle, zoom_start=15)
folium.Marker(richmond_circle).add_to(map_richmond)
for lon, lat in cluster_centers:
    folium.Circle([lat, lon], radius=500, color='green', fill=False).add_to(map_richmond) 
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.Circle([lat, lon], radius=250, color='#0000ff00', fill=True, fill_color='#0066ff', fill_opacity=0.07).add_to(map_richmond)
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.CircleMarker([lat, lon], radius=2, color='blue', fill=True, fill_color='blue', fill_opacity=1).add_to(map_richmond)
folium.GeoJson(richmond_boroughs, style_function=boroughs_style, name='geojson').add_to(map_richmond)
map_richmond

candidate_area_addresses = []
print('==============================================================')
print('Addresses of centers of areas recommended for further analysis')
print('==============================================================\n')
for lon, lat in cluster_centers:
    addr = get_address(google_api_key, lat, lon).replace(', India', '')
    candidate_area_addresses.append(addr)    
    x, y = lonlat_to_xy(lon, lat)
    d = calc_xy_distance(x, y, richmond_circle_x, richmond_circle_y)
    print('{}{} => {:.1f}km from Richmond Circle'.format(addr, ' '*(50-len(addr)), d/1000))
    

map_richmond = folium.Map(location=roi_center, zoom_start=14)
folium.Circle(richmond_circle, radius=50, color='red', fill=True, fill_color='red', fill_opacity=1).add_to(map_richmond)
for lonlat, addr in zip(cluster_centers, candidate_area_addresses):
    folium.Marker([lonlat[1], lonlat[0]], popup=addr).add_to(map_richmond) 
for lat, lon in zip(good_latitudes, good_longitudes):
    folium.Circle([lat, lon], radius=250, color='#0000ff00', fill=True, fill_color='#0066ff', fill_opacity=0.05).add_to(map_richmond)
map_richmond