Spaces:
Sleeping
Sleeping
File size: 5,983 Bytes
bbe788d 897ea2d bbe788d 9fb5d19 a580030 0697975 bbe788d c9c2156 bbe788d a580030 ff1b036 a580030 2737b30 ff1b036 2737b30 a580030 bbe788d 643a822 81d3eef 059564b 81d3eef 02c8225 23133d1 02c8225 b5290a2 02c8225 bbe788d 02c8225 ff1b036 9fb5d19 ff1b036 287a688 80eb9a3 044f186 b5290a2 ba96f19 80eb9a3 044f186 bbe788d 81d3eef 9fb5d19 ba96f19 9fb5d19 b5290a2 ff1b036 81d3eef be17c91 5db2dc0 be17c91 5db2dc0 bbe788d 6262455 bbe788d a580030 ff1b036 d669f57 a580030 fd31ef9 efca6f0 897ea2d ff1b036 897ea2d a580030 897ea2d 4e8c737 897ea2d ff1b036 fd31ef9 ff1b036 e949094 897ea2d 7d796d3 4fc77fd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
import streamlit as st
import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from geopy.distance import geodesic
import googlemaps
from geopy.exc import GeocoderTimedOut
# Function to calculate distance in meters between two coordinates
def calculate_distance(lat1, lon1, lat2, lon2):
coords_1 = (lat1, lon1)
coords_2 = (lat2, lon2)
return geodesic(coords_1, coords_2).meters
# Function to apply KNN and return Vunit values
def knn_predict(df, target_column, features_columns, k=5):
# Separate features and target variable
X = df[features_columns]
y = df[target_column]
# Create KNN regressor
knn = KNeighborsRegressor(n_neighbors=k)
# Fit the model
knn.fit(X, y)
# Use the model to predict Vunit for the filtered_data
predictions = knn.predict(df[features_columns])
return predictions
# Set wide mode
st.set_page_config(layout="wide")
# Set dark theme
st.markdown(
"""
<style>
body {
color: white;
background-color: #1e1e1e;
}
.st-df-header, .st-df-body, .st-df-caption {
color: #f8f9fa; /* Bootstrap table header text color */
}
.st-eb {
background-color: #343a40; /* Streamlit exception box background color */
}
</style>
""",
unsafe_allow_html=True
)
# Create a DataFrame with sample data
data = pd.read_excel('ven_ter_fim_PEDÓ.xlsx')
# Initialize variables to avoid NameError
selected_coords = 'Direcionada'
radius_visible = True
custom_address_initial = 'Av. Senador Alberto Pasqualini, 177 - Centro, Lajeado - RS, 95900-034' # Initial custom address
custom_lat = data['latitude'].median()
custom_lon = data['longitude'].median()
radius_in_meters = 1500
filtered_data = data # Initialize with the entire dataset
# Find the maximum distance between coordinates
max_distance = 0
for index, row in data.iterrows():
distance = calculate_distance(row['latitude'], row['longitude'], data['latitude'].mean(), data['longitude'].mean())
if distance > max_distance:
max_distance = distance
# Calculate a zoom level based on the maximum distance
zoom_level = round(17 - np.log10(max_distance))
title_html = """
<span style='color: gray; font-size: 40px;'>aval</span>
<span style='color: white; font-size: 40px;'>ia</span>
<span style='color: gray; font-size: 40px;'>.NEXUS</span>
"""
# Create a sidebar for controls
with st.sidebar:
#st.title('avalia.se')
st.sidebar.markdown(title_html, unsafe_allow_html=True)
selected_coords = st.selectbox('Selecione o tipo de pesquisa', ['Ampla', 'Direcionada'])
if selected_coords == 'Direcionada':
custom_address = st.text_input('Informe o endereço', custom_address_initial)
radius_visible = True # Show radius slider for custom coordinates
# No need to initialize max_distance_all here
else:
custom_address = "Lajeado, Rio Grande do Sul, Brazil" # Default address
radius_visible = False # Hide radius slider for random coordinates
max_distance_all = 0 # Initialize max_distance_all here
max_distance_all = 0 # Initialize max_distance_all here
# Geocode the custom address using the Google Maps API
gmaps = googlemaps.Client(key='AIzaSyDoJ6C7NE2CHqFcaHTnhreOfgJeTk4uSH0') # Replace with your API key
try:
location = gmaps.geocode(custom_address)[0]['geometry']['location']
custom_lat, custom_lon = location['lat'], location['lng']
except (IndexError, GeocoderTimedOut):
st.error("Erro: Não foi possível geocodificar o endereço fornecido. Por favor, verifique e tente novamente.")
# Slider for setting the zoom level
if selected_coords == 'Direcionada':
zoom_level = st.slider('Nível de zoom', min_value=1, max_value=15, value=zoom_level)
else:
for index, row in data.iterrows():
distance_all = calculate_distance(row['latitude'], row['longitude'], data['latitude'].mean(), data['longitude'].mean())
if distance_all > max_distance_all:
max_distance_all = distance_all
# Calculate a zoom level based on the maximum distance of the entire dataset
zoom_level_all = round(15 - np.log10(max_distance_all))
# Slider for setting the zoom level based on the entire dataset
zoom_level = st.slider('Nível de zoom', min_value=1, max_value=15, value=zoom_level_all)
# Conditionally render the radius slider
if radius_visible:
radius_in_meters = st.slider('Selecione raio (em metros)', min_value=100, max_value=5000, value=1000)
# Filter data based on the radius
if selected_coords == 'Direcionada':
filtered_data = data[data.apply(lambda x: calculate_distance(x['latitude'], x['longitude'], custom_lat, custom_lon), axis=1) <= radius_in_meters]
filtered_data = filtered_data.dropna() # Drop rows with NaN values
# Add a custom CSS class to the map container
st.markdown(f"""<style>
.map {{
width: 100%;
height: 100vh;
}}
</style>""", unsafe_allow_html=True)
# Check if KNN should be applied
if selected_coords == 'Direcionada' and radius_visible:
# Apply KNN and get predicted Vunit values
predicted_vunit = knn_predict(filtered_data, 'Vunit', ['latitude', 'longitude', 'Area']) # Update with your features
# Add predicted Vunit values to filtered_data
filtered_data['Predicted_Vunit'] = predicted_vunit
# Display the map and filtered_data
with st.container():
if selected_coords == 'Direcionada':
st.map(filtered_data, zoom=zoom_level, use_container_width=True)
elif selected_coords == 'Ampla':
st.map(data, zoom=zoom_level, use_container_width=True)
# Display the predicted Vunit values if applicable
if 'Predicted_Vunit' in filtered_data.columns:
st.write("Valores (R$/m²) previstos com algoritmo KNN:")
st.write(filtered_data[['latitude', 'longitude', 'Vunit', 'Predicted_Vunit']]) |