Create app.py

app.py

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+
+import gradio as gr
+import pandas as pd
+import geopandas as gpd
+from shapely.geometry import Point # Importar Point para a conversão
+import folium
+from folium.plugins import MeasureControl
+import html
+from rapidfuzz import process
+
+# --- CARREGAMENTO E PRÉ-PROCESSAMENTO DE DADOS ---
+
+try:
+    # Carrega os eixos (ruas) e projeta para o sistema de coordenadas padrão (WGS84)
+    gdf_eixos = gpd.read_file("Eixos.shp", engine="fiona")
+    gdf_eixos_proj = gdf_eixos.to_crs("EPSG:4326")
+    print("Shapefile de Eixos carregado com sucesso.")
+
+    # 1. Criar o dicionário de mapeamento unificado: NOME -> CDLOG
+    mapa_nome_para_cdlog = {}
+    df_mapeamento = gdf_eixos_proj[['NMIDELOG', 'NMIDEABR', 'CDLOG']].dropna(subset=['CDLOG'])
+
+    for _, row in df_mapeamento.iterrows():
+        cdlog = row['CDLOG']
+        if pd.notna(row['NMIDELOG']):
+            mapa_nome_para_cdlog[row['NMIDELOG']] = cdlog
+        if pd.notna(row['NMIDEABR']):
+            mapa_nome_para_cdlog[row['NMIDEABR']] = cdlog
+            
+    # 2. Criar a lista de busca unificada com todos os nomes únicos
+    lista_nomes_ruas_oficiais = list(mapa_nome_para_cdlog.keys())
+    
+    print(f"{len(lista_nomes_ruas_oficiais)} nomes de ruas únicos (de NMIDELOG e NMIDEABR) pré-processados para busca.")
+
+except Exception as e:
+    print(f"ERRO CRÍTICO: Não foi possível carregar ou processar o Shapefile 'Eixos.shp'.")
+    print(f"Verifique se o caminho de rede está correto e acessível.")
+    print(f"Erro original: {e}")
+    exit()
+
+
+# --- FUNÇÕES DE PROCESSAMENTO (BACK-END) ---
+
+def encontrar_melhor_correspondencia(nome_rua_usuario, score_minimo=85):
+    """
+    Encontra a melhor correspondência para um nome de rua na lista oficial.
+    A comparação é feita em CAIXA ALTA para ser insensível ao caso.
+    """
+    if not nome_rua_usuario or pd.isna(nome_rua_usuario):
+        return None, None, 0
+
+    nome_rua_upper = str(nome_rua_usuario).upper()
+    melhor_match = process.extractOne(nome_rua_upper, lista_nomes_ruas_oficiais)
+    
+    if melhor_match and melhor_match[1] >= score_minimo:
+        nome_encontrado = melhor_match[0]
+        score = melhor_match[1]
+        cdlog_encontrado = mapa_nome_para_cdlog[nome_encontrado]
+        return int(cdlog_encontrado), nome_encontrado, score
+    
+    return None, None, melhor_match[1] if melhor_match else 0
+
+
+def geocodificar_lote_por_nome(df, coluna_nome_rua, coluna_num):
+    """
+    Função principal que processa o DataFrame inteiro.
+    """
+    if df is None:
+        return None, None, None
+
+    resultados_finais = []
+    falhas_geocodificacao = []
+
+    for index, row in df.iterrows():
+        nome_rua_original = row[coluna_nome_rua]
+        numero = pd.to_numeric(row[coluna_num], errors='coerce')
+        
+        dados_linha = row.to_dict()
+        cdlog, nome_correspondido, score = encontrar_melhor_correspondencia(nome_rua_original)
+        
+        dados_linha['CDLOG_ENCONTRADO'] = cdlog
+        dados_linha['NM_CORRESPONDIDO'] = nome_correspondido
+        dados_linha['SCORE_SIMILARIDADE'] = score
+
+        if not cdlog:
+            falhas_geocodificacao.append({**dados_linha, 'MOTIVO_FALHA': 'Nome da rua não encontrado com similaridade aceitável'})
+            resultados_finais.append({**dados_linha, 'x': None, 'y': None})
+            continue
+
+        if pd.isna(numero):
+            falhas_geocodificacao.append({**dados_linha, 'MOTIVO_FALHA': 'Número do imóvel inválido ou vazio'})
+            resultados_finais.append({**dados_linha, 'x': None, 'y': None})
+            continue
+
+        numero = int(numero)
+        segmentos = gdf_eixos_proj[gdf_eixos_proj['CDLOG'] == cdlog]
+        cond = (segmentos['NRPARINI'] <= numero) & (segmentos['NRPARFIN'] >= numero) if numero % 2 == 0 else (segmentos['NRIMPINI'] <= numero) & (segmentos['NRIMPFIN'] >= numero)
+        segmento_valido = segmentos[cond]
+
+        if segmento_valido.empty:
+            falhas_geocodificacao.append({**dados_linha, 'MOTIVO_FALHA': 'Número do imóvel fora do intervalo da rua encontrada'})
+            resultados_finais.append({**dados_linha, 'x': None, 'y': None})
+            continue
+            
+        linha_eixo = segmento_valido.iloc[0]
+        geom = linha_eixo.geometry
+        ini, fim = (linha_eixo['NRPARINI'], linha_eixo['NRPARFIN']) if numero % 2 == 0 else (linha_eixo['NRIMPINI'], linha_eixo['NRIMPFIN'])
+
+        if pd.isna(ini) or pd.isna(fim) or fim == ini: frac = 0.5
+        else: frac = (numero - ini) / (fim - ini)
+        
+        frac = max(0, min(1, frac))
+        ponto = geom.interpolate(geom.length * frac)
+        
+        dados_linha['x'] = ponto.x
+        dados_linha['y'] = ponto.y
+        resultados_finais.append(dados_linha)
+
+    df_resultado = pd.DataFrame(resultados_finais)
+    df_falhas = pd.DataFrame(falhas_geocodificacao)
+    output_path = "dados_geocodificados.xlsx"
+    df_resultado.to_excel(output_path, index=False)
+    
+    return df_resultado, df_falhas, output_path
+
+# --- FUNÇÃO DO MAPA CORRIGIDA ---
+def gerar_mapa_interpolado(df_interpolado):
+    """Gera o mapa HTML a partir do DataFrame com coordenadas."""
+    if df_interpolado is None:
+        return "<div>Mapa não gerado. Processe os dados primeiro.</div>"
+    
+    df_valido = df_interpolado.dropna(subset=['x', 'y']).copy()
+    if df_valido.empty:
+        return "<div>Nenhum ponto válido para exibir no mapa.</div>"
+
+    # --- INÍCIO DA CORREÇÃO ---
+    # 1. Converter o DataFrame do pandas para um GeoDataFrame do geopandas
+    gdf_valido = gpd.GeoDataFrame(
+        df_valido, 
+        geometry=gpd.points_from_xy(df_valido.x, df_valido.y),
+        crs="EPSG:4326"  # Definir o sistema de coordenadas (importante!)
+    )
+
+    # 2. Calcular o centro do mapa de forma eficiente
+    # Pega os limites geográficos de todos os pontos (min_x, min_y, max_x, max_y)
+    bounds = gdf_valido.total_bounds
+    center_y = (bounds[1] + bounds[3]) / 2
+    center_x = (bounds[0] + bounds[2]) / 2
+    
+    m = folium.Map(location=[center_y, center_x], zoom_start=13, tiles='CartoDB positron')
+    # --- FIM DA CORREÇÃO ---
+    
+    MeasureControl(primary_length_unit='meters', secondary_length_unit='kilometers').add_to(m)
+
+    # O resto da função permanece igual
+    for _, row in gdf_valido.iterrows():
+        conteudo_popup = "<br>".join([f"<b>{col}</b>: {row[col]}" for col in gdf_valido.columns if col != 'geometry'])
+        folium.CircleMarker(
+            location=[row['y'], row['x']],
+            radius=5, color='#007BFF', fill=True, fill_color='#007BFF',
+            fill_opacity=0.8, popup=folium.Popup(conteudo_popup, max_width=350)
+        ).add_to(m)
+        
+    mapa_html = m.get_root().render()
+    mapa_html_escapado = html.escape(mapa_html)
+    return f"<iframe srcdoc=\"{mapa_html_escapado}\" width='100%' height='1000px' style='border:none;'></iframe>"
+
+
+# --- Funções de Interface (Gradio) ---
+def carregar_abas(arquivo_excel):
+    if arquivo_excel is None: return gr.update(choices=[]), None
+    xls = pd.ExcelFile(arquivo_excel.name)
+    abas = xls.sheet_names
+    return gr.update(choices=abas, value=abas[0] if abas else None), abas[0] if abas else None
+
+def listar_colunas(arquivo_excel, aba_selecionada):
+    if arquivo_excel is None or aba_selecionada is None:
+        return gr.update(choices=[]), gr.update(choices=[]), None, "", None
+    df = pd.read_excel(arquivo_excel.name, sheet_name=aba_selecionada)
+    colunas = df.columns.tolist()
+    return (gr.update(choices=colunas), gr.update(choices=colunas), df,
+            f"O DataFrame possui {df.shape[0]} linhas e {df.shape[1]} colunas.", df)
+
+def reset_app():
+    return None, gr.update(choices=[], value=None), "", None, None, None, None, None, None, None
+
+# --- INTERFACE GRÁFICA (GRADIO) ---
+with gr.Blocks(theme=gr.themes.Soft(), title="Geocodificador Simplificado") as demo:
+    estado_df = gr.State()
+
+    gr.Markdown("# Geocodificador de Endereços")
+    gr.Markdown("Faça o upload de uma planilha Excel, selecione as colunas com **NOME da rua** e **NÚMERO**, e o aplicativo encontrará as coordenadas.")
+
+    with gr.Tabs():
+        with gr.TabItem("Processo de Geocodificação"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    arquivo = gr.File(label="1. Selecione um arquivo Excel", file_types=[".xlsx"])
+                    dropdown_abas = gr.Dropdown(label="2. Selecione uma aba da planilha", interactive=True)
+                    dropdown_nome_rua = gr.Dropdown(label="3. Selecione a coluna com o NOME da rua", interactive=True)
+                    dropdown_num = gr.Dropdown(label="4. Selecione a coluna com o NÚMERO do imóvel", interactive=True)
+                    btn_processar = gr.Button("5. Geocodificar Endereços", variant="primary")
+                
+                with gr.Column(scale=3):
+                    linhas_colunas_output = gr.Textbox(label="Dimensões da Tabela", interactive=False)
+                    tabela_output = gr.Dataframe(label="Pré-visualização dos Dados", height=400)
+
+            gr.Markdown("---")
+            gr.Markdown("### Resultados")
+            
+            with gr.Row():
+                tabela_interpolada = gr.Dataframe(label="Dados com Coordenadas e Verificação de Endereço", interactive=False, height=350)
+                falhas_output = gr.Dataframe(label="Relatório de Endereços Não Encontrados", interactive=False, height=350)
+            
+            arquivo_excel_output = gr.File(label="Baixar resultado completo como Excel", interactive=False)
+
+        with gr.TabItem("Mapa de Resultados"):
+            mapa_html = gr.HTML(label="Visualização Geográfica dos Dados")
+
+    btn_clear = gr.Button("Limpar Tudo e Recomeçar", variant="stop")
+
+    # --- LÓGICA DE EVENTOS DA INTERFACE ---
+    arquivo.change(fn=carregar_abas, inputs=arquivo, outputs=[dropdown_abas, dropdown_abas])
+
+    dropdown_abas.change(
+        fn=listar_colunas,
+        inputs=[arquivo, dropdown_abas],
+        outputs=[dropdown_nome_rua, dropdown_num, estado_df, linhas_colunas_output, tabela_output]
+    )
+    
+    btn_processar.click(
+        fn=geocodificar_lote_por_nome, 
+        inputs=[estado_df, dropdown_nome_rua, dropdown_num], 
+        outputs=[tabela_interpolada, falhas_output, arquivo_excel_output]
+    ).then(
+        fn=gerar_mapa_interpolado,
+        inputs=tabela_interpolada,
+        outputs=mapa_html
+    )
+
+    btn_clear.click(fn=reset_app, inputs=None, outputs=[
+        arquivo, dropdown_abas, linhas_colunas_output, dropdown_nome_rua, dropdown_num, 
+        tabela_output, tabela_interpolada, falhas_output, arquivo_excel_output, mapa_html
+    ])
+
+
+# --- INICIAR A APLICAÇÃO ---
+if __name__ == "__main__":
+    demo.launch(debug=True)