# importando bibliotecas necessárias import pandas as pd import numpy as np import gradio as gr from gradio import components from gradio import Interface import xlsxwriter from reportlab.lib.pagesizes import letter from reportlab.platypus import SimpleDocTemplate, Paragraph from reportlab.lib.styles import getSampleStyleSheet import shutil import os import plotly.express as px #-----------------# #função para relatórios em pdf def save_results_to_pdf(results_formatados, intervalo_confiança, valores_finais): doc = SimpleDocTemplate("resultados.pdf", pagesize=letter) styles = getSampleStyleSheet() # Create a list of elements to include in the PDF elements = [] # Add the formatted results to the PDF formatted_results = Paragraph(results_formatados, styles["Normal"]) elements.append(formatted_results) # Add the intervalo de confianca to the PDF confianca = Paragraph(intervalo_confiança, styles["Normal"]) elements.append(confianca) # Add the valores calculados to the PDF calculados = Paragraph(valores_finais, styles["Normal"]) elements.append(calculados) # Build the PDF doc.build(elements) #-----------------# #função para renderizar um dataframe def renderizar_dataframe(df): try: # Renderize o DataFrame como uma tabela HTML com rolagem horizontal df_html = df.to_html(classes='table table-striped', table_id='planilha', escape=False) # Não escapar caracteres especiais # Use uma div com estilo CSS para permitir a rolagem horizontal tabela_com_rolagem = f'
{df_html}
' # Retorna a tabela com rolagem como HTML return tabela_com_rolagem except Exception as e: return f"Erro ao processar o DataFrame: {str(e)}" #-----------------# #função para criar um mapa no plotly def plotar_mapa_com_dois_dataframes(df1, df2): fig1 = px.scatter_mapbox( df1, lat='lat', lon='lon', zoom=12.5, center={"lat": df1['lat'].mean(), "lon": df1['lon'].mean()}, color_discrete_sequence=['#008B8B'], ) fig1.update_traces(marker=dict(size=10)) # Define o tamanho dos marcadores para o DataFrame 1 fig2 = px.scatter_mapbox( df2, lat='lat', lon='lon', color_discrete_sequence=['orange'], ) fig2.update_traces(marker=dict(size=20)) # Define o tamanho dos marcadores para o DataFrame 2 # Combine as duas figuras em uma única figura for data in fig2.data: fig1.add_trace(data) # Personalize o layout do mapa, se desejar fig1.update_layout( mapbox_style="carto-positron", ) # Mostrar o mapa fig1.show() return fig1 #-----------------# # Função de avaliação do imóvel def avaliacao_imovel(planilha, num_linhas_desejadas=1, finalidade='Defina o tipo de imovel', caract_avaliando='Defina o item 1 de Fundamentação', ident_dados='Defina o item 3 de Fundamentação'): # Lendo a aba 'avaliando' da planilha df_avaliando = pd.read_excel(planilha.name, 'avaliando') # Lendo a aba 'dados' da planilha, limitando o número de linhas df_dados = pd.read_excel(planilha.name, 'dados').iloc[:int(num_linhas_desejadas)] #-----------------# # fator de atratividade local (fal) df_transp = df_dados.copy() df_transp = df_transp[['Atratividade local']] df_transp['fal'] = round(df_avaliando['Atratividade local'][0] / df_transp['Atratividade local'], 2) df_transp = df_transp[['fal']] #-----------------# # fator de correção da área construída (fac) df_area_const = df_dados.copy() df_area_const = df_area_const[['Área Construída']] df_area_const['razao'] = (df_area_const['Área Construída'] / df_avaliando['Área Construída'][0]) df_area_const['dif'] = abs(df_area_const['Área Construída'] - df_avaliando['Área Construída'][0]) # 30% da área do terreno do avaliando x_ac = 0.3 * df_avaliando['Área Construída'][0] # coeficiente n conforme a diferença entre a área do avaliando e dos dados df_area_const['n'] = df_area_const['dif'].apply(lambda dif: 0.250 if dif <= x_ac else 0.125) df_area_const['fac'] = round((df_area_const['razao']) ** (df_area_const['n']), 2) df_area_const = df_area_const[['fac']] #-----------------# # fator de correção da área do terreno (fat) df_area_terreno = df_dados.copy() df_area_terreno = df_area_terreno[['Área Terreno']] df_area_terreno['razao'] = (df_area_terreno['Área Terreno'] / df_avaliando['Área Terreno'][0]) df_area_terreno['dif'] = abs(df_area_terreno['Área Terreno'] - df_avaliando['Área Terreno'][0]) # 30% da área do terreno do avaliando x_at = 0.3 * df_avaliando['Área Terreno'][0] # coeficiente n conforme a diferença entre a área do avaliando e dos dados df_area_terreno['n'] = df_area_terreno['dif'].apply(lambda dif: 0.250 if dif <= x_at else 0.125) df_area_terreno['fat'] = round((df_area_terreno['razao']) ** (df_area_terreno['n']), 2) df_area_terreno = df_area_terreno[['fat']] #-----------------# # fator profundidade (fpe) # Define a função coeficiente_profundidade antes de criar os DataFrames def coeficiente_profundidade(row): A = row['Área Terreno'] t = row['Testada'] pe = round(A/t, 2) hipotese_1 = A > 5000 and pe > 90 hipotese_2 = A <= 5000 or (A > 5000 and pe <= 90) if finalidade == "Tipologias com área construída": coef_pe = 1 else: if hipotese_1: coef_pe = round(4.8 * (t ** 0.2) * (A ** -0.4), 3) else: if pe < 20: coef_pe = round((pe/20) ** 0.5, 3) elif 20 <= pe < 33: coef_pe = 1 elif 33 <= pe < 90: coef_pe = round((33/pe) ** 0.5, 3) else: coef_pe = 0.6 return coef_pe # Cria os DataFrames df_profundidade e df_profundidade_aval df_profundidade = df_dados[['Área Terreno','Testada']].copy() df_profundidade['coef_pe'] = df_profundidade.apply(coeficiente_profundidade, axis=1) df_profundidade_aval = df_avaliando[['Área Terreno','Testada']].copy() df_profundidade_aval['coef_pe'] = df_profundidade_aval.apply(coeficiente_profundidade, axis=1) df_profundidade['fpe'] = round(df_profundidade_aval['coef_pe'][0]/df_profundidade['coef_pe'],2) df_profundidade = df_profundidade[['fpe']] #-----------------# # fator topografia (ftp) # dicionário topografia dict_topo = { 'plano <5%': 1, 'aclive_leve 5% e 30%': 0.95, 'declive_leve 5% e 30%': 0.90, 'aclive_acentuado >30%': 0.85, 'declive_acentuado >30%': 0.80, 'não se aplica' : 1, } # Cria os DataFrames df_topografia e df_topografia_aval df_topografia = df_dados.copy() df_topografia = df_topografia[['Topografia']] df_topografia_aval = df_avaliando.copy() df_topografia_aval = df_topografia_aval[['Topografia']] # Função para mapear os valores de Topografia para cod_topo usando o dicionário def mapear_cod_topo(topografia): return dict_topo.get(topografia, 0) # 0 como valor padrão caso a topografia não esteja no dicionário # Aplicando a função para criar a coluna cod_topo em df_dados e df_avaliando df_topografia['coef_tp'] = df_topografia['Topografia'].apply(mapear_cod_topo) df_topografia_aval['coef_tp'] = df_topografia_aval['Topografia'].apply(mapear_cod_topo) df_topografia['ftp'] = round(df_topografia_aval['coef_tp'][0]/df_topografia['coef_tp'],2) df_topografia = df_topografia[['ftp']] #-----------------# # fator relevo (frv) # dicionário relevo dict_rel = { 'plana' : 1.1, 'ondulada': 1.00, 'montanhosa/acidentada': 0.80, 'não se aplica' : 1.00, } # Cria os DataFrames df_relevo e df_relevo_aval df_relevo = df_dados.copy() df_relevo = df_relevo[['Relevo']] df_relevo_aval = df_avaliando.copy() df_relevo_aval = df_relevo_aval[['Relevo']] # Função para mapear os valores de Relevo para cod_rel usando o dicionário def mapear_cod_rel(relevo): return dict_rel.get(relevo, 0) # 0 como valor padrão caso o relevo não esteja no dicionário # Aplicando a função para criar a coluna cod_rel em df_dados e df_avaliando df_relevo['coef_rv'] = df_relevo['Relevo'].apply(mapear_cod_rel) df_relevo_aval['coef_rv'] = df_relevo_aval['Relevo'].apply(mapear_cod_rel) df_relevo['frv'] = round(df_relevo_aval['coef_rv'][0]/df_relevo['coef_rv'],2) df_relevo = df_relevo[['frv']] #-----------------# # fator superfície (fsp) # dicionário superfície dict_sup = { 'Seca': 1.00, 'Região inundável mas não atingida': 0.90, 'Região inundável mas atingida periodicamente': 0.70, 'Alagada': 0.60, 'não se aplica' : 1.00, } # Cria os DataFrames df_superficie e df_superficie_aval df_superficie = df_dados.copy() df_superficie = df_superficie[['Superfície']] df_superficie_aval = df_avaliando.copy() df_superficie_aval = df_superficie_aval[['Superfície']] # Função para mapear os valores de Superfície para cod_sup usando o dicionário def mapear_cod_sup(superficie): return dict_sup.get(superficie, 0) # 0 como valor padrão caso a superficie não esteja no dicionário # Aplicando a função para criar a coluna cod_sup em df_dados e df_avaliando df_superficie['coef_sp'] = df_superficie['Superfície'].apply(mapear_cod_sup) df_superficie_aval['coef_sp'] = df_superficie_aval['Superfície'].apply(mapear_cod_sup) df_superficie['fsp'] = round(df_superficie_aval['coef_sp'][0]/df_superficie['coef_sp'],2) df_superficie = df_superficie[['fsp']] #-----------------# # fator aproveitamento (fap) # dicionário aproveitamento dict_apr = { 'Loteamento': 1.00, 'Indústria': 0.90, 'Culturas': 0.80, 'não se aplica' : 1.00, } # Cria os DataFrames df_aproveitamento e df_aproveitamento_aval df_aproveitamento = df_dados.copy() df_aproveitamento = df_aproveitamento[['Aproveitamento']] df_aproveitamento_aval = df_avaliando.copy() df_aproveitamento_aval = df_aproveitamento_aval[['Aproveitamento']] # Função para mapear os valores de Aproveitamento para cod_apr usando o dicionário def mapear_cod_apr(aproveitamento): return dict_apr.get(aproveitamento, 0) # 0 como valor padrão caso o aproveitamento não esteja no dicionário # Aplicando a função para criar a coluna cod_apr em df_dados e df_avaliando df_aproveitamento['coef_ap'] = df_aproveitamento['Aproveitamento'].apply(mapear_cod_apr) df_aproveitamento_aval['coef_ap'] = df_aproveitamento_aval['Aproveitamento'].apply(mapear_cod_apr) df_aproveitamento['fap'] = round(df_aproveitamento_aval['coef_ap'][0]/df_aproveitamento['coef_ap'],2) df_aproveitamento = df_aproveitamento[['fap']] #-----------------# # fator acessibilidade viária (fav) # dicionário acessibilidade dict_ace = { 'Ótima': 1.00, 'Muito boa': 0.95, 'Boa': 0.90, 'Desfavorável': 0.80, 'Má': 0.75, 'Péssima': 0.70, 'não se aplica' : 1.00, } # Cria os DataFrames df_acesso e df_acesso_aval df_acesso = df_dados.copy() df_acesso = df_acesso[['Acessibilidade']] df_acesso_aval = df_avaliando.copy() df_acesso_aval = df_acesso_aval[['Acessibilidade']] # Função para mapear os valores de Acessibilidade para cod_ace usando o dicionário def mapear_cod_ace(acesso): return dict_ace.get(acesso, 0) # 0 como valor padrão caso a acessibilidade não esteja no dicionário # Aplicando a função para criar a coluna cod_ace em df_dados e df_avaliando df_acesso['coef_av'] = df_acesso['Acessibilidade'].apply(mapear_cod_ace) df_acesso_aval['coef_av'] = df_acesso_aval['Acessibilidade'].apply(mapear_cod_ace) df_acesso['fav'] = round(df_acesso_aval['coef_av'][0]/df_acesso['coef_av'],2) df_acesso = df_acesso[['fav']] #-----------------# # fator idade aparente e conservação (fic) # dicionário padrão construtivo dict_ic = { 'id<5_novo': 1.00, 'id<5_bom': 0.95, 'id<5_reparos simples': 0.80, 'id<5_reparos importantes': 0.45, 'id entre 6 e 10_novo': 0.95, 'id entre 6 e 10_bom': 0.90, 'id entre 6 e 10_reparos simples': 0.75, 'id entre 6 e 10_reparos importantes': 0.40, 'id entre 11 e 30_novo': 0.85, 'id entre 11 e 30_bom': 0.80, 'id entre 11 e 30_reparos simples': 0.65, 'id entre 11 e 30_reparos importantes': 0.35, 'id entre 31 e 50_novo': 0.55, 'id entre 31 e 50_bom': 0.50, 'id entre 31 e 50_reparos simples': 0.45, 'id entre 31 e 50_reparos importantes': 0.25, 'id>50_novo': 0.30, 'id>50_bom': 0.20, 'id>50_reparos simples': 0.15, 'id>50_reparos importantes': 0.10, 'não se aplica' : 1, } # Cria os DataFrames df_idade_cons e df_idade_cons_aval df_idade_cons = df_dados.copy() df_idade_cons = df_idade_cons[['Idade aparente e conservação']] df_idade_cons_aval = df_avaliando.copy() df_idade_cons_aval = df_idade_cons_aval[['Idade aparente e conservação']] # Função para mapear os valores de idade aparente e conservação para cod_id_cons usando o dicionário def mapear_cod_id_cons(id_cons): return dict_ic.get(id_cons, 0) # 0 como valor padrão caso a Idade e Conservação não esteja no dicionário # Aplicando a função para criar a coluna cod_ic em df_dados e df_avaliando df_idade_cons['coef_ic'] = df_idade_cons['Idade aparente e conservação'].apply(mapear_cod_id_cons) df_idade_cons_aval['coef_ic'] = df_idade_cons_aval['Idade aparente e conservação'].apply(mapear_cod_id_cons) df_idade_cons['fic'] = round(df_idade_cons_aval['coef_ic'][0] / df_idade_cons['coef_ic'],2) df_idade_cons = df_idade_cons[['fic']] #-----------------# # fator padrão construtivo (fpd) # dicionário padrão construtivo dict_pad = { 'baixo_residencial': 1.00, 'médio/baixo_residencial': 1.15, 'médio_residencial': 1.30, 'médio/alto_residencial': 1.45, 'alto_residencial': 1.65, 'baixo_comercial': 1.00, 'médio/baixo_comercial': 1.08, 'médio_comercial': 1.15, 'médio/alto_comercial': 1.25, 'alto_comercial': 1.40, 'não se aplica' : 1, } # Cria os DataFrames df_padrao e df_padrao_aval df_padrao = df_dados.copy() df_padrao = df_padrao[['Padrão construtivo']] df_padrao_aval = df_avaliando.copy() df_padrao_aval = df_padrao_aval[['Padrão construtivo']] # Função para mapear os valores de padrão construtivo para cod_pad usando o dicionário def mapear_cod_pad(padrao): return dict_pad.get(padrao, 0) # 0 como valor padrão caso o padrão não esteja no dicionário # Aplicando a função para criar a coluna cod_pad em df_dados e df_avaliando df_padrao['coef_pd'] = df_padrao['Padrão construtivo'].apply(mapear_cod_pad) df_padrao_aval['coef_pd'] = df_padrao_aval['Padrão construtivo'].apply(mapear_cod_pad) df_padrao['fpd'] = round(df_padrao_aval['coef_pd'][0]/df_padrao['coef_pd'],2) df_padrao = df_padrao[['fpd']] #-----------------# # fator vagas de estacionamento (fvg) df_vaga = df_dados[['Vagas']].copy() df_vaga_aval = df_avaliando[['Vagas']].copy() # Calcular a diferença entre as colunas 'Vagas' nos dois DataFrames df_vaga['dif'] = df_vaga['Vagas'] - df_vaga_aval['Vagas'][0] # Definir a função para o cálculo da coluna 'fvg' def calculate_fcg(dif, vagas): if dif == 0: return 1 else: return 1 - 0.067 * dif # Aplicar a função para calcular a coluna 'fvg' df_vaga['fvg'] = round(df_vaga.apply(lambda row: calculate_fcg(row['dif'], row['Vagas']), axis=1), 2) df_vaga = df_vaga[['fvg']] #-----------------# # fator extra (à critério do avaliador) (fex) df_exc = df_dados.copy() df_exc = df_exc[['Coeficiente extra']] df_exc['fex'] = round(df_avaliando['Coeficiente extra'][0] / df_exc['Coeficiente extra'], 2) df_exc = df_exc[['fex']] #-----------------# # concatemando o dataframe principal com as dataframes dos fatores result = pd.concat([df_dados, df_transp, df_area_const, df_area_terreno, df_profundidade, df_topografia, df_relevo, df_superficie,df_aproveitamento, df_acesso, df_idade_cons, df_padrao, df_vaga, df_exc], axis=1) result['Valor_desc'] = round(result['Valor']*(result['fof']), 2) if finalidade == "Tipologias com área construída": result['Vunit'] = round((result['Valor_desc']/result['Área Construída']), 2) else: result['Vunit'] = round((result['Valor_desc']/result['Área Terreno']), 2) result = result[['lat','lon','Atratividade local', 'Área Construída', 'Área Terreno', 'Testada', 'Topografia', 'Relevo','Superfície','Aproveitamento','Acessibilidade', 'Idade aparente e conservação', 'Padrão construtivo', 'Vagas', 'Coeficiente extra', 'Valor', 'fof','Valor_desc', 'Vunit','fal', 'fac', 'fat','fpe', 'ftp','frv','fsp', 'fap','fav', 'fic','fpd', 'fvg', 'fex']] #if finalidade == "Tipologias com área construída": #result = result[['lat','lon','Atratividade local', 'Área Construída', 'Área Terreno', #'Idade aparente e conservação', 'Padrão construtivo', 'Vagas','Coeficiente extra', 'Valor', #'fof','Valor_desc', 'Vunit','fal', 'fac', 'fat', 'fic','fpd', 'fvg', 'fex']] #else: #result = result[['lat','lon','Atratividade local', 'Área Terreno', 'Testada', 'Topografia', 'Superfície', #'Coeficiente extra', 'Valor', 'fof','Valor_desc','Vunit','fal', 'fat','fpe', 'ftp','fsp', 'fex']] result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \ result['fac'] * \ result['fat'] * \ result['fpe'] * \ result['ftp'] * \ result['frv'] * \ result['fsp'] * \ result['fap'] * \ result['fav'] * \ result['fic'] * \ result['fpd'] * \ result['fvg'] * \ result['fex'], 2) #if finalidade == "Tipologias com área construída": #result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \ #result['fac'] * \ #result['fat'] * \ #result['fic'] * \ #result['fpd'] * \ #result['fvg'] * \ #result['fex'], 2) #else: #result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \ #result['fat'] * \ #result['fpe'] * \ #result['ftp'] * \ #result['fsp'] * \ #result['fex'], 2) #-----------------# # RESULTADOS ESTATÍSTICOS INICIAIS num = len(result) media = round(result['Vunit_hom'].mean(), 2) valor_hom_máximo = round(result['Vunit_hom'].max(), 2) valor_hom_mínimo = round(result['Vunit_hom'].min(), 2) limite_superior = round(media * 1.3 ,2) limite_inferior = round(media * 0.7 ,2) desvio_padrao = round(result['Vunit_hom'].std(), 2) coef_variacao = round((desvio_padrao / media)*100, 2) # CRITÉRIO DE CHAUVENET dict_vc = { 2: 1.15,3: 1.38,4: 1.54,5: 1.65,6: 1.73,7: 1.80,8: 1.85,9: 1.91,10: 1.96,11: 1.99, 12: 2.03,13: 2.06,14: 2.10,15: 2.13,16: 2.16,17: 2.18,18: 2.20,19: 2.21,20: 2.24, 21: 2.26,22: 2.28,23: 2.30,24: 2.31,25: 2.33,26: 2.35,27: 2.36,28: 2.37,29: 2.38, 30: 2.93 } vc = dict_vc[num] vc result['z-score'] = abs((result['Vunit_hom'] - media) / desvio_padrao) result['Status'] = np.where(result['z-score'] > vc, 'rejeitado', 'aceito') # para gerar uma tabela na interface result_render = renderizar_dataframe(result) # DADOS REMOVIDOS outliers = result[result['Status'] == 'rejeitado'] # REMOÇÃO DE OUTLIERS PELO CRITÉRIO DE CHAUVENET result = result[result['Status'] != 'rejeitado'] # GRAU DE FUNDAMENTAÇÃO # item_1 - Graus de Fundamentação (Caracterização do imóvel avaliando) if caract_avaliando == "Completa quanto a todos os fatores analisados": item_1 = 3 elif caract_avaliando == "Completa quanto aos fatores utilizados no tratamento": item_1 = 2 else: item_1 = 1 # item_2 - Graus de Fundamentação (Quantidade mínima de dados) if num >= 12: item_2 = 3 elif 5 <= num <12: item_2 = 2 elif 3 <= num <5: item_2 = 1 else: item_2 = 0 # item_3 - Graus de Fundamentação (Identificação dos dados) if ident_dados == "Apresentação de informações relativas a todas as características dos dados analisados, com foto e características observadas pelo autor do laudo": item_3 = 3 elif ident_dados == "Apresentação de informações relativas a todas as características dos dados analisados": item_3 = 2 else: item_3 = 1 # item_4 - Graus de Fundamentação ( Intervalo admissível de ajuste para o conjunto de fatores) max = result.iloc[:, 19:32].max().max() min = result.iloc[:, 19:32].min().min() if num >= 5: if min >= 0.8 and max <= 1.2: item_4 = 3 elif min >= 0.5 and max <= 2.0: item_4 = 2 else: item_4 = 1 # Condição ausente aqui else: if min >= 0.8 and max <= 1.2: item_4 = 1 else: item_4 = 0 # enquadramento soma = item_1 + item_2 + item_3 + item_4 if soma > 10 and item_2 == 3 and item_4 == 3 and item_1 >= 2 and item_3 >= 2: fundamentacao = "III" elif soma > 6 and item_2 >= 2 and item_4 >= 2 and item_1 >= 1 and item_3 >= 1: fundamentacao = "II" elif soma > 4 and item_2 >= 1 and item_4 >= 1 and item_1 >= 1 and item_3 >= 1: fundamentacao = "I" else: fundamentacao = "Fora dos critérios" # RESULTADOS ESTATÍSTICOS FINAIS num_dados = len(df_dados) num = len(result) dados_outliers = len(outliers) media = round(result['Vunit_hom'].mean(), 2) valor_hom_máximo = round(result['Vunit_hom'].max(), 2) valor_hom_mínimo = round(result['Vunit_hom'].min(), 2) limite_superior = round(media * 1.3 ,2) limite_inferior = round(media * 0.7 ,2) desvio_padrao = round(result['Vunit_hom'].std(), 2) coef_variacao = round((desvio_padrao / media)*100, 2) # Crie uma string formatada com os RESULTADOS ESTATÍSTICOS FINAIS resultados_formatados = f""" Número de dados iniciais: {num_dados} dados Número de dados utilizados: {num} dados Valor Crítico (Chauvenet): {vc} Outliers: {dados_outliers} dado(s) Média saneada: {media} R$/m² Valor máximo: {valor_hom_máximo} R$/m² Valor mínimo: {valor_hom_mínimo} R$/m² Lim superior (Média*1,3): {limite_superior} R$/m² Lim inferior (Média*0,7): {limite_inferior} R$/m² Desvio padrão: {desvio_padrao} R$/m² Coeficiente variação: {coef_variacao} % """ # INTEREVALO DE CONFIANÇA DE 80% # importando a tabela de t de student df_t = pd.read_excel('TABELAS.xlsx','t') # número de dados n = result.shape[0]-1 # "t" de student gl = df_t[df_t['gl (n-1)'] == n] tc = gl.iloc[0, 3] # limites infeiror e superior do IC de 80% e amplitude li_IC = round(media - tc * ((desvio_padrao/(num-1)**0.5)), 2) ls_IC = round(media + tc * ((desvio_padrao/(num-1)**0.5)), 2) A = round(ls_IC - li_IC, 2) A_perc = round((A / media)*100, 2) def calcular_grau(a): if a <= 30: return "Grau III" elif a <= 40: return "Grau II" elif a <= 50: return "Grau I" else: return "Fora dos critérios" precisao = calcular_grau(A_perc) # Crie uma string formatada com o INTEREVALO DE CONFIANÇA DE 80% intervalo_confiança = f""" t student: {tc} Média saneada: {media} R$/m² limite infeiror IC_80%: {li_IC} R$/m² limite superior IC_80%: {ls_IC} R$/m² Aplitude: {A} R$/m² Aplitude percentual: {A_perc} % Grau de Fundamentação {fundamentacao} Grau de Precisão: {precisao} """ # VALOR CALCULADO A PARTIR DOS VALORES HOMOGENEIZADOS UTILIZANDO O CRITÉRIO DE CLASSAS D0 ABUNAHMAN # dividindo a amplitude em 3 classes C = round((A / 3), 2) # calculando os intervalos das 3 classes C1 = round(result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].count(), 2) C2 = round(result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].count(), 2) C3 = round(result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].count(), 2) # crinado listas com os valores encontrados nos intervalos list_C1 = result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].tolist() list_C2 = result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].tolist() list_C3 = result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].tolist() pC1 = round(sum(C1 * elemento for elemento in list_C1), 2) pC2 = round(sum(C2 * elemento for elemento in list_C2), 2) pC3 = round(sum(C3 * elemento for elemento in list_C3), 2) divisor = ((C1 * C1) if C1 != 0 else 0) +((C2 * C2) if C2 != 0 else 0) + ((C3 * C3) if C3 != 0 else 0) media_pond = round((pC1 + pC2 + pC3) / divisor, 2) # VALORES CALCULADOS if finalidade == "Tipologias com área construída": Valor_imóvel = round(media * df_avaliando['Área Construída'], 2).item() else: Valor_imóvel = round(media * df_avaliando['Área Terreno'], 2).item() LI = round(Valor_imóvel* 0.85, 2) LS = round(Valor_imóvel* 1.15, 2) if finalidade == "Tipologias com área construída": Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Construída'], 2).item() else: Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Terreno'], 2).item() LI_classes = round(Valor_imóvel_2* 0.85, 2) LS_classes = round(Valor_imóvel_2* 1.15, 2) # Crie uma string formatada com os VALORES CALCULADOS if finalidade == "Tipologias com área construída": area = df_avaliando['Área Construída'].item() else: area = df_avaliando['Área Terreno'].item() valores_finais = f""" Área avaliando: {area} m² --------- Valor (média simples): R$ {Valor_imóvel} LI: R$ {LI} LS: R$ {LS} Vu (média simples): R$/m² {media} --------- Valor (critério classes): R$ {Valor_imóvel_2} LI: R$ {LI_classes} LS: R$ {LS_classes} Vu (critério classes): R$/m² {media_pond} """ #-----------------# # OUTPUTS # Crie um objeto ExcelWriter para escrever no arquivo Excel nome_com_extensao = os.path.basename(planilha.name) nome_do_arquivo = os.path.splitext(nome_com_extensao)[0] # Defina o nome da planilha de saída com base no nome da planilha de entrada output_file = f"{nome_do_arquivo}_relatório.xlsx" #output_file = 'relatório.xlsx' (substituído pelo código acima) with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer: # Salve o DataFrame 'avaliando' na planilha 'relatório' df_avaliando.to_excel(writer, sheet_name='avaliando', index=False) #-----------------# # Salve o DataFrame 'result' na planilha 'relatório' df_dados.to_excel(writer, sheet_name='dados', index=False) #-----------------# # Salve o DataFrame 'dado_hom' na planilha 'relatório' result.to_excel(writer, sheet_name='dados_hom', index=False) #-----------------# # Salve o DataFrame 'outliers' na planilha 'relatório' outliers.to_excel(writer, sheet_name='outliers', index=False) #-----------------# # Crie um novo DataFrame com os resultados estatísticos result_estatisticos = pd.DataFrame({ 'Número de dados iniciais': [num], 'Número de dados utilizados': [num_dados], 'Valor Crítico (Chauvenet)': [vc], 'Outliers': [dados_outliers], 'Média': [media], 'Valor homogeneizado máximo': [valor_hom_máximo], 'Valor homogeneizado mínimo': [valor_hom_mínimo], 'Limite superior (Média x 1,3)': [limite_superior], 'Limite inferior (Média x 0,7)': [limite_inferior], 'Desvio padrão': [desvio_padrao], 'Coeficiente_variacao (%)': [coef_variacao] }) # Transponha o DataFrame result_estatisticos = result_estatisticos.T.reset_index() # Defina os nomes das colunas do novo DataFrame result_estatisticos.columns = ['Nome da Coluna', 'Valor'] result_estatisticos.to_excel(writer, sheet_name='resultados', index=False) #-----------------# # Crie um novo DataFrame com os resultados do IC result_ic = pd.DataFrame({ 'Número de dados': [n], 't student': [tc], 'Limite superior do IC de 80%': [ls_IC], 'Limite inferior do IC de 80%': [li_IC], 'Amplitude': [A], 'Amplitude%':[A_perc], 'Grau de Fundamentação': [fundamentacao], 'Grau de Precisão': [precisao] }) # Transponha o DataFrame result_ic = result_ic.T.reset_index() # Defina os nomes das colunas do novo DataFrame result_ic.columns = ['Nome da Coluna', 'Valor'] result_ic.to_excel(writer, sheet_name='IC', index=False) #-----------------# # Crie um novo DataFrame com os resultados do cálculo das classes de Abunahman result_classes = pd.DataFrame({ 'C = Amplitude / 3': [round(C, 2)], 'li_IC = limite inferior do IC': [round(li_IC, 2)], 'li_IC + C = limite inferior do IC + C': [round(li_IC + C, 2)], 'ls_IC - C = limite superior do IC + C': [round(ls_IC - C, 2)], 'ls_IC = limite superior do IC': [round(ls_IC, 2)], 'C1 = quantidade de dados na classe 1': [C1], 'C2 = quantidade de dados na classe 2': [C2], 'C3 = quantidade de dados na classe 3': [C3], 'list_C1 = listagem de dados na classe 1': [list_C1], 'list_C2 = listagem de dados na classe 2': [list_C2], 'list_C3 = listagem de dados na classe 3': [list_C3], 'Soma da multiplicação dos valor pelos pesos - classe 1': [pC1], 'Soma da multiplicação dos valor pelos pesos - classe 2': [pC2], 'Soma da multiplicação dos valor pelos pesos - classe 3': [pC3], 'Divisor da somas das classes': [divisor], 'Média ponderada': [media_pond] }) # Transponha o DataFrame result_classes = result_classes.T.reset_index() # Defina os nomes das colunas do novo DataFrame result_classes.columns = ['Nome da Coluna', 'Valor'] result_classes.to_excel(writer, sheet_name='classes', index=False) #-----------------# # Crie um novo DataFrame com os resultados do valor do imóvel result_valores = pd.DataFrame({ 'Valor (média simples): R$': [Valor_imóvel], 'LI: R$': [LI], 'LS: R$': [LS], 'Vu (média simples): R$/m²': [media], 'Valor (critério classes) R$:': [Valor_imóvel_2], 'Vu (critério classes): R$/m²': [media_pond], 'LI_classes: R$': [LI_classes], 'LS_classes: R$': [LS_classes] }) # Transponha o DataFrame result_valores = result_valores.T.reset_index() # Defina os nomes das colunas do novo DataFrame result_valores.columns = ['Nome da Coluna', 'Valor'] result_valores.to_excel(writer, sheet_name='valor', index=False) #-----------------# mapa = plotar_mapa_com_dois_dataframes(result, df_avaliando) #mapa = criar_mapa(df_avaliando) #novo #-----------------# # Salve o DataFrame 'result' em uma planilha result.to_excel(output_file, index=False) #result.to_excel('relatório.xlsx', index=False) (substituído pelo código acima) #-----------------# save_results_to_pdf(resultados_formatados, intervalo_confiança, valores_finais) result.to_excel(output_file, index=False) #-----------------# # Retorna tanto a planilha quanto os resultados formatados return output_file, 'resultados.pdf', result_render, resultados_formatados, intervalo_confiança, valores_finais, mapa #novo # Interface do Gradio com input como arquivo XLS ou XLSX interface = gr.Interface( fn=avaliacao_imovel, inputs=[ gr.components.File(label="Upload planilha", type="file", info="Importação de planilha padrão com o avaliando e os dados"), #gr.components.Number(label="Número de linhas desejadas", default=10), gr.Slider(1, 30, value=1, label="Número de dados", info="Escolha o número de dados", step=1), #gr.components.Dropdown(label="Tipo de imóvel", choices=["Terrenos e glebas","Tipologias com área construída"], default="Tipologias com área construída"), gr.Radio(["Terrenos e glebas", "Tipologias com área construída"], label="Tipo de Imóvel", info="Escolha o tipo de imóvel"), gr.Radio(["Completa p/ todos fatores analisados", "Completa p/ os fatores utilizados", "Situação paradigma"], label="Caracterização do avaliando", info="Para enquadramento quanto a fundamentação - ítem 1 da tabela 6 do anexo 2 - NBR 14.653-2"), gr.Radio(["Apresentação de informações relativas a todas as características dos dados analisados, com foto e características observadas pelo autor do laudo", "Apresentação de informações relativas a todas as características dos dados analisados", "Apresentação de informações relativas a todas as características dos dados correspondentes aos fatores analisados"], label="Identificação dos dados",info="Para enquadramento quanto a fundamentação - ítem 3 da tabela 6 do anexo 2 - NBR 14.653-2", ) ], outputs=[ gr.components.File(label="Download planilha"), gr.components.File(label="Download Relatório em PDF"), gr.components.HTML(label="Resultado Renderizado"), gr.components.Textbox(label="Resultados estatísticos"), gr.components.Textbox(label="Intervalo de confiança de 80%"), gr.components.Textbox(label="Valores Calculados"), gr.Plot(label="Geolocalização da amostra"), ], live=False, capture_session=True, theme=gr.themes.Monochrome(), title = "avalia.FACTOR", description=f"""

avalia.se

Aplicativo MCDDM com tratamento por fatores / Faça o upload de uma planilha XLS ou XLSX com os dados / Para um exemplo de estrutura de planilha, você pode baixar aqui

""" ) # Executar o aplicativo Gradio if __name__ == "__main__": interface.launch(debug=True)