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
9afa68f
 
 
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: 46px;'>aval</span>
    <span style='color: white; font-size: 46px;'>ia</span>
    <span style='color: gray; font-size: 46px;'>.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']])