Python - Integrar codigo principal a tkinder

import numpy as np

import matplotlib.pyplot as plt

import skfuzzy as fuzz

import pandas as pd

U=np.linspace(0,10,101)

#Función que describe los numeros difusos para el parametro SISTEMA ESTRUCTURAL, Las variables son llamadas como se_x, donde x es A,B,C,D

se_A=fuzz.trimf(U,[0,3,5])

se_B=fuzz.trimf(U,[3,7,10])

se_C=fuzz.trimf(U,[5,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para el paramero sistema estructural

se_I=fuzz.trimf(U,[7,10,10])

#Función que describe los numeros difusos para el parametro CALIDAD DEL SISTEMA ESTRUCTURAL, Las variables son llamadas como csr_x, donde x es A,B,C,D

csr_A=fuzz.trapmf(U,[0,0,3,5])

csr_B=fuzz.trimf(U,[0,5,7])

csr_C=fuzz.trimf(U,[3,5,10])

csr_D=fuzz.trimf(U,[3,7,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para el paramero Calidad del sistema resistente csr_I

csr_I=fuzz.trimf(U,[7,10,10])

#Función que describe los numeros difusos para el parametro RESISTENCIA ESTRUCTURRAL, Las variables son llamadas como re_x, donde x es A,B,C,D

re_A=fuzz.trimf(U,[0,3,5])

re_B=fuzz.trimf(U,[0,5,7])

re_C=fuzz.trimf(U,[5,7,10])

re_D=fuzz.trimf(U,[7,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para el paramero Resistencia estructural re_I

re_I=fuzz.trapmf(U,[3,5,7,10])

#Función que describe los numeros difusos para el parametro POCISIÓN DE LA CIMENTACIÓN, Las variables son llamadas como pc_x, donde x es A,B,C,D

pc_A=fuzz.trimf(U,[0,3,5])

pc_B=fuzz.trimf(U,[0,3,5])

pc_C=fuzz.trimf(U,[3,5,10])

pc_D=fuzz.trapmf(U,[3,7,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para el pocisión de la cimentación pc_I

pc_I=fuzz.trimf(U,[5,7,10])

#Función que describe los numeros difusos para el parametro SUELO Y PENDIENTE DEL TERRENO, Las variables son llamadas como sp_x, donde x es A,B,C,D

sp_A=fuzz.trimf(U,[0,0,3])

sp_B=fuzz.trapmf(U,[0,3,5,7])

sp_C=fuzz.trimf(U,[3,7,7])

sp_D=fuzz.trimf(U,[6,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para suelo y pendiente del terreno sp_I

sp_I=fuzz.trapmf(U,[6,7,7,10])

#Función que describe los numeros difusos para el parametro DIAFRAGMA DEL SISTEMA, Las variables son llamadas como ds_x, donde x es A,B,C,D

ds_A=fuzz.trimf(U,[0,3,5])

ds_B=fuzz.trapmf(U,[0,3,5,6])

ds_C=fuzz.trimf(U,[3,5,10])

ds_D=fuzz.trimf(U,[5,7,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para diafragmas del sistema ds_I

ds_I=fuzz.trapmf(U,[4,5,7,10])

#Función que describe los numeros difusos para el parametro CONFIGURACIÓN EN PLANTA, Las variables son llamadas como cp_x, donde x es A,B,C,D

cp_A=fuzz.trapmf(U,[0,0,3,5])

cp_B=fuzz.trimf(U,[0,5,7])

cp_C=fuzz.trapmf(U,[4,5,7,10])

cp_D=fuzz.trimf(U,[7,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para Configuración en planta cp_I

cp_I=fuzz.trapmf(U,[3,5,7,9])

#Función que describe los numeros difusos para el parametro CONFIGURACIÓN EN ELEVACIÓN, Las variables son llamadas como ce_x, donde x es A,B,C,D

ce_A=fuzz.trimf(U,[0,0,4])

ce_B=fuzz.trimf(U,[1,3,6])

ce_C=fuzz.trapmf(U,[2,5,7,10])

ce_D=fuzz.trapmf(U,[4,7,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para Configuración en elevación ce_I

ce_I=fuzz.trapmf(U,[4,6,7,10])

#Función que describe los numeros difusos para el parametro DISTANCIA ENTRE MUROS, Las variables son llamadas como dm_x, donde x es A,B,C,D

dm_A=fuzz.trapmf(U,[0,0,3,5])

dm_B=fuzz.trapmf(U,[0,3,5,7])

dm_C=fuzz.trapmf(U,[3,5,7,10])

dm_D=fuzz.trapmf(U,[0,3,5,7])

#Función que describe el numero difuso del coeficiente de valor de importancia para distancia entre muros dm_I

dm_I=fuzz.trimf(U,[4,7,10])

#Función que describe los numeros difusos para el parametro Tipo de Cubierta, Las variables son llamadas como tp_x, donde x es A,B,C,D

tp_A=fuzz.trimf(U,[0,0,5])

tp_B=fuzz.trimf(U,[2,5,7])

tp_C=fuzz.trimf(U,[4,7,10])

tp_D=fuzz.trimf(U,[5,7,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para tipo de cubierta tp_I

tp_I=fuzz.trimf(U,[4,7,10])

#Función que describe los numeros difusos para el parametro Estado de conservación, Las variables son llamadas como ec_x, donde x es A,B,C,D

ec_A=fuzz.trapmf(U,[0,0,3,4])

ec_B=fuzz.trimf(U,[2,5,7])

ec_C=fuzz.trimf(U,[3,7,10])

ec_D=fuzz.trimf(U,[7,10,10])

#Función que describe el numero difuso del coeficiente de valor de importancia para estado de conservación ec_I

ec_I=fuzz.trapmf(U,[4,7,10,10])

#DENOMINADOR SUMA DE LOS I

# Crear la lista de conjuntos difusos

fuzzy_list = [se_I,csr_I,re_I,pc_I,sp_I,ds_I,cp_I,ce_I,dm_I,tp_I,ec_I]

# Inicializar el resultado con el primer elemento de la lista

u_resultI, mf_resultI = U, fuzzy_list[0]

# Iterar sobre los elementos restantes y sumarlos

for fuzzy_set in fuzzy_list[1:]:

    # Sumar difusa utilizando la función dsw_add

    u_resultI, mf_resultI = fuzz.dsw_add(u_resultI, mf_resultI, U, fuzzy_set, 11)

#MULTIPLICACIONES

x = [[se_A,se_B,se_C],[csr_A,csr_B,csr_C,csr_D],[re_A, re_B, re_C, re_D],[pc_A,pc_B,pc_C,pc_D], [sp_A, sp_B, sp_C, sp_D],[ds_A,ds_B,ds_C,ds_D],[cp_A,cp_B,cp_C,cp_D],[ce_A,ce_B,ce_C,ce_D],[dm_A,dm_B,dm_C,dm_D],[tp_A,tp_B,tp_C,tp_D],[ec_A,ec_B,ec_C,ec_D]]

fuzzy_list = [se_I,csr_I,re_I,pc_I,sp_I,ds_I,cp_I,ce_I,dm_I,tp_I,ec_I]

funcion_list = [0,1,2,3,4,5,6,7,8,9,10]

U_mult = []

z_mult = []

for funcion in funcion_list:

  opcion = input("Inserta una letra (a, b, c, d): ")

  if funcion == 0:

    if opcion.lower() == 'a':

      number_funcion = x[funcion][0]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    elif opcion.lower() == 'b':

      number_funcion = x[funcion][1]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    elif opcion.lower() == 'c':

      number_funcion = x[funcion][2]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    else:

      flag = False

      print("Opción no válida. Por favor, elige entre 'a', 'b', 'c' o 'd'.")

      break

  else:

    if opcion.lower() == 'a':

      number_funcion = x[funcion][0]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    elif opcion.lower() == 'b':

      number_funcion = x[funcion][1]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    elif opcion.lower() == 'c':

      number_funcion = x[funcion][2]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    elif opcion.lower() == 'd':

      number_funcion = x[funcion][3]

      I=fuzzy_list[funcion]

      UZ_result, z_result = fuzz.dsw_mult(U, number_funcion, U, I, 11)

      U_mult.append (UZ_result)

      z_mult.append (z_result)

    else:

      flag = False

      print("Opción no válida. Por favor, elige entre 'a', 'b', 'c' o 'd'.")

      break

#SUMA DE LAS MULTIPLICACIONES

# Inicializar el resultado con el primer elemento de la lista

u_result, mf_result = U_mult[0], z_mult[0]

# Iterar sobre los elementos restantes y sumarlos

for u_m, z_m in zip(U_mult[1:],z_mult[1:]):

    # Sumar difusa utilizando la función dsw_add

    u_result, mf_result = fuzz.dsw_add(u_result, mf_result, u_m, z_m, 11)

#DIVISION

U_div,z_div=fuzz.dsw_div(u_result,mf_result,u_resultI,mf_resultI,11)

def desfusificar_centroide(conjunto_difuso):

    # Calcula el centroide (centro de masa)

    centroide = sum(conjunto_difuso) / len(conjunto_difuso)

    return centroide

# Ejemplo de uso

conjunto_difuso = U_div

resultado_desfusificacion = desfusificar_centroide(conjunto_difuso)

print("Resultado de la desfusificación:", resultado_desfusificacion)

numero_usuario = resultado_desfusificacion

lista_valores = U_div

valor_cercano = None

con = 0

for valor in lista_valores:

    if valor_cercano is None or abs(valor - numero_usuario) < abs(valor_cercano - numero_usuario):

        valor_cercano = valor

        con +=1

print(f"El valor más cercano a {numero_usuario} en la lista es: {valor_cercano}, Su pocisión es:{con}")

print(f"El valor de la vulnerabilidad es  {round(valor_cercano,2)} y su pertenencia es: {z_div[con-1]}")

import tkinter as tk

from tkinter import ttk, filedialog, messagebox

from PIL import Image, ImageTk

def cargar_imagen(ruta, subsample):

    try:

        imagen = Image.open(ruta)

        imagen = imagen.resize((imagen.width // subsample, imagen.height // subsample))

        return ImageTk.PhotoImage(imagen)

    except Exception as e:

        messagebox.showerror("Error", f"Error al cargar imagen: {e}")

        return None

def cargar_archivo_excel():

    archivo_excel = filedialog.askopenfilename(filetypes=[("Archivos de Excel", "*.xlsx *.xls")])

    if archivo_excel:

        print("Archivo Excel seleccionado:", archivo_excel)

def obtener_datos(entry_parametros):

    parametros = [entry.get() for entry in entry_parametros]

    print("Parámetros ingresados:", parametros)

def crear_label_con_imagen(ventana, ruta, subsample):

    imagen = cargar_imagen(ruta, subsample)

    if imagen:

        label = tk.Label(ventana, image=imagen, bg="white")

        label.image = imagen

        return label

    return None

def crear_widgets(ventana):

    titulo_font = ("Courier New", 25, "bold")

    texto_inicial = tk.Label(ventana, text="ECIVUL", font=titulo_font, bg="white")

    texto_inicial.grid(row=0, column=0, columnspan=2, padx=10, pady=10)

    opciones_archivo = tk.Menu(ventana)

    opciones_archivo.add_command(label="Guardar", command=guardar_archivo)

    opciones_archivo.add_separator()

    opciones_archivo.add_command(label="Salir", command=ventana.destroy)

    desplegable_archivo = tk.Menu(ventana)

    desplegable_archivo.add_cascade(label="Archivo", menu=opciones_archivo)

    ventana.config(menu=desplegable_archivo)

    boton_evaluacion_grupal = tk.Button(ventana, text="Evaluación Grupal", command=enviar_evaluacion_grupal)

    boton_evaluacion_grupal.grid(row=2, column=0, padx=10, pady=5)

    boton_evaluacion_individual = tk.Button(ventana, text="Evaluación Individual", command=enviar_evaluacion_individual)

    boton_evaluacion_individual.grid(row=2, column=1, padx=10, pady=5)

    info_label = tk.Label(ventana, text="i", font=("Helvetica", 12), bg="white", cursor="hand2")

    info_label.grid(row=0, column=1, sticky=tk.NE, padx=10, pady=10)

    info_label.bind("<Button-1>", lambda event: mostrar_informacion())

    nuevo_texto = ("Este programa fue desarrollado usando la metodología de opinión de expertos y calibrada mediante números difusos por los ingenieros Gustavo Chio Cho "

                   "y Esperanza Maldonado y presentada en el libro Vulnerabilidad Sísmica en Centros Urbanos.")

    texto = tk.Label(ventana, text=nuevo_texto, wraplength=300, bg="white")

    texto.grid(row=3, column=0, columnspan=2, padx=10, pady=5)

    etiqueta_imagen1 = crear_label_con_imagen(ventana, "C:/Users/carlo/Downloads/Casas.png", 6)

    if etiqueta_imagen1:

        etiqueta_imagen1.grid(row=1, column=0, columnspan=2, padx=10, pady=5)

    etiqueta_imagen2 = crear_label_con_imagen(ventana, "C:/Users/carlo/Downloads/Logo.png", 5)

    if etiqueta_imagen2:

        etiqueta_imagen2.grid(row=4, column=0, columnspan=2, padx=10, pady=5)

def enviar_evaluacion_grupal():

    ventana_grupal = tk.Toplevel()

    ventana_grupal.title("ECIVUL")

    fondo_imagen = cargar_imagen("C:/Users/carlo/Downloads/Casas.png", subsample=4)

    if fondo_imagen:

        fondo_label = tk.Label(ventana_grupal, image=fondo_imagen, bg="white")

        fondo_label.image = fondo_imagen

        fondo_label.place(x=0, y=0, relwidth=1, relheight=1)

    letrero_ecivul = tk.Label(ventana_grupal, text="ECIVUL", font=("Courier New", 25, "bold"))

    letrero_ecivul.pack(pady=5)

    ecivul_imagen = cargar_imagen("C:/Users/carlo/Downloads/Logo.png", subsample=5)

    if ecivul_imagen:

        ecivul_label = tk.Label(ventana_grupal, image=ecivul_imagen, bg="white")

        ecivul_label.image = ecivul_imagen

        ecivul_label.pack(pady=10)

    estilo_nota = {"font": ("Arial", 9), "foreground": "black", "background": "lightgray"}

    texto_nota_1 = "Este módulo te permite calcular la vulnerabilidad sísmica"

    texto_nota_2 = "de un grupo de casas y te devuelve una hoja de Excel con"

    texto_nota_3 = "la vulnerabilidad y su respectiva pertenencia"

    nota_label_1 = tk.Label(ventana_grupal, text=texto_nota_1, **estilo_nota, justify="center")

    nota_label_2 = tk.Label(ventana_grupal, text=texto_nota_2, **estilo_nota, justify="center")

    nota_label_3 = tk.Label(ventana_grupal, text=texto_nota_3, **estilo_nota, justify="center")

    nota_label_1.pack(pady=2)

    nota_label_2.pack(pady=2)

    nota_label_3.pack(pady=2)

    cargar_button = tk.Button(ventana_grupal, text="Cargar Excel", command=cargar_archivo_excel)

    cargar_button.pack(pady=10)

    resultado_label = tk.Label(ventana_grupal, text="")

    resultado_label.pack(pady=10)

def enviar_evaluacion_individual():

    ventana_evaindi = tk.Toplevel()

    ventana_evaindi.title("ECIVUL")

    ventana_evaindi.geometry("400x600")

    fondo_imagen = cargar_imagen("C:/Users/carlo/Downloads/Casas.png", subsample=4)

    if fondo_imagen:

        fondo_label = tk.Label(ventana_evaindi, image=fondo_imagen, bg="white")

        fondo_label.image = fondo_imagen

        fondo_label.place(x=0, y=0, relwidth=1, relheight=1)

    titulo_label = ttk.Label(ventana_evaindi, text="ECIVUL", font=("Courier New", 25, ""), background="white")

    titulo_label.pack()

    imagen_tk = cargar_imagen("C:/Users/carlo/Downloads/Logo.png", subsample=5)

    if imagen_tk:

        label_imagen = tk.Label(ventana_evaindi, image=imagen_tk, compound=tk.TOP, anchor='n', bg="white")

        label_imagen.image = imagen_tk

        label_imagen.pack()

    frame_parametros = ttk.Frame(ventana_evaindi)

    frame_parametros.pack(pady=10)

    etiquetas_parametros = [

        "Sistema Estructural", "Calidad del sistema resistente", "Resistencia estructural",

        "Posición de la cimentación", "Suelo y pendiente del terreno", "Diafragmas horizontales",

        "Configuración en planta", "Configuración en elevación", "Distancia máxima entre muros",

        "Tipo de cubierta", "Estado de conservación"

    ]

    entry_parametros = []

    for i, etiqueta_parametro in enumerate(etiquetas_parametros):

        etiqueta = ttk.Label(frame_parametros, text=etiqueta_parametro)

        etiqueta.grid(row=i, column=0, pady=5, padx=5, sticky="w")

        entry = ttk.Entry(frame_parametros, width=20)

        entry.grid(row=i, column=1, pady=5, padx=5, sticky="w")

        entry_parametros.append(entry)

    boton_calcular = ttk.Button(ventana_evaindi, text="Calcular", command=lambda: obtener_datos(entry_parametros))

    boton_calcular.pack()

    resultado_label = ttk.Label(ventana_evaindi, text="")

    resultado_label.pack()

def guardar_archivo():

    archivo_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Archivos de Texto", "*.txt"), ("Todos los archivos", "*.*")])

    if archivo_path:

        with open(archivo_path, 'w') as file:

            file.write("Datos a guardar")

def mostrar_informacion():

    mensaje = ("Esta es la versión 00 de este programa.\n"

               "Para sugerencias, comuníquese con:\n"

               "valentina.vasquez@mail.escuelaing.edu.co\n"

               "o\n"

               "carlos.anturi@mail.escuelaing.edu.co")

    messagebox.showinfo("Información", mensaje)

ventana = tk.Tk()

ventana.title("ECI-VUL")

ventana.configure(bg="white")

crear_widgets(ventana)

ventana.mainloop()