app.py

#!/usr/bin/env python
# coding: utf-8

# # 1. Pre-procesamiento de datos

# In[1]:


import cv2
import numpy as np


# In[2]:


def redimensionar(imagenes,tamano):
    imagenes_ajustadas = []
    for imagen in imagenes: 
        imagen_temporal = cv2.resize (imagen,tamano)
        imagenes_ajustadas.append(imagen_temporal)
    return imagenes_ajustadas


# In[3]:


def contraste(imagenes, valor_contraste):
    imagenes_ajustadas = []
    for imagen in imagenes: 
        imagen_temporal = np.clip(imagen*valor_contraste,0,255)
        imagenes_ajustadas.append(imagen_temporal)
    return imagenes_ajustadas


# In[4]:


def rasgos(imagenes,width):
    imagenes_ajustadas = []
    
    for imagen in imagenes:
        img = imagen
        img = cv2.resize(img, (width,int(width*img.shape[0]/img.shape[1])))

        c = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT)
        mag = np.sqrt(c[:,:,0]**2 + c[:,:,1]**2)
        spectralResidual = np.exp(np.log(mag) - cv2.boxFilter(np.log(mag), -1, (3,3)))

        c[:,:,0] = c[:,:,0] * spectralResidual / mag
        c[:,:,1] = c[:,:,1] * spectralResidual / mag
        c = cv2.dft(c, flags = (cv2.DFT_INVERSE | cv2.DFT_SCALE))
        mag = c[:,:,0]**2 + c[:,:,1]**2
        cv2.normalize(cv2.GaussianBlur(mag,(9,9),3,3), mag, 0., 1., cv2.NORM_MINMAX)
        
        imagenes_ajustadas.append(mag)
        
    return imagenes_ajustadas


# In[130]:


import gradio as gr
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import models


modelo1 = tf.keras.models.load_model('modeloIA_1.h5')
modelo2 = tf.keras.models.load_model('modeloIA_2.h5')
modelo3 = tf.keras.models.load_model('modeloIA_3.h5')
modelo4 = tf.keras.models.load_model('modeloIA_4.h5')

modelo1v = tf.keras.models.load_model('modeloIA_1v.h5')
modelo2v = tf.keras.models.load_model('modeloIA_2v.h5')
modelo3v = tf.keras.models.load_model('modeloIA_3v.h5')
modelo4v = tf.keras.models.load_model('modeloIA_4v.h5')


# In[131]:


def ejecutar_modelo(imagen_app):
    imagen_app = cv2.cvtColor (imagen_app,cv2.COLOR_BGR2GRAY)
    
    imagenes_app = []
    imagenes_app.append(imagen_app)
    
    imagen_temporal = rasgos (imagenes_app, 128)
    imagen_temporal = redimensionar(imagen_temporal,(256,256))
    imagen_temporal = contraste(imagen_temporal,0.4)
    imagen_temporal = np.expand_dims(imagen_temporal, axis=3)
    
    resultado1 = modelo1.predict(imagen_temporal)
    resultado1 = int (np.argmax (resultado1, axis=1))
    
    resultado2 = modelo2.predict(imagen_temporal)
    resultado2 = int (np.argmax (resultado2, axis=1))
    
    resultado3 = modelo3.predict(imagen_temporal)
    resultado3 = int (np.argmax (resultado3, axis=1))
    
    resultado4 = modelo4.predict(imagen_temporal)
    resultado4 = int (np.argmax (resultado4, axis=1))
    
    clase1 = ['armonia', 'ausencia', 'contraste', 'ninguno']
    clase2 =['ausencia', 'fragmentacion', 'ninguno', 'unidad']
    clase3 = ['ausencia', 'equilibrio', 'inestabilidad', 'ninguno']
    clase4 = ['agudeza', 'ausencia', 'difusividad', 'ninguno']
    
    valor1 = ''
    if clase1[resultado1] != 'ausencia' and clase1[resultado1] != 'ninguno':
        valor1 = ': ' + str(int(np.clip(np.round(modelo1v.predict(imagen_temporal) + 1)[0][0],1,5)))
        
    valor2 = ''
    if clase2[resultado2] != 'ausencia' and clase2[resultado2] != 'ninguno':
        valor2 = ': ' + str(int(np.clip(np.round(modelo2v.predict(imagen_temporal) + 1)[0][0],1,5)))
        
    valor3 = ''
    if clase3[resultado3] != 'ausencia' and clase3[resultado3] != 'ninguno':
        valor3 = ': ' + str(int(np.clip(np.round(modelo3v.predict(imagen_temporal) + 1)[0][0],1,5)))
        
    valor4 = ''
    if clase4[resultado4] != 'ausencia' and clase4[resultado4] != 'ninguno':
        valor4 = ': ' + str(int(np.clip(np.round(modelo4v.predict(imagen_temporal) + 1)[0][0],1,5)))
    
    return clase1[resultado1] + valor1, clase3[resultado3] + valor3, clase2[resultado2] + valor2, clase4[resultado4] + valor4

    
# In[132]:

from gradio.themes.base import Base
from gradio.themes.utils import colors, fonts, sizes

theme1 = gr.themes.Base(
    primary_hue = "emerald",
    secondary_hue = "blue",
    neutral_hue = "blue",
    text_size = gr.themes.Size(xs='10px', sm='12px', md='14px', lg='16px', xl='22px', xxl='16px',xxs='9px'),
    font = [gr.themes.GoogleFont('Supreme'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
)

theme1.set(
    body_background_fill = "#EDEFF0",
    background_fill_primary = "#FFFFFF50",
    background_fill_secondary = "#EDEFF000",
    #background_fill_secondary = "#EDEFF0",
    #azul omar #415DA1
    
    body_text_size='12px',
    button_primary_background_fill = "#3E67B7",
    button_border_width = '*block_label_border_width',
    button_primary_border_color = "#52A6AA",
    button_primary_text_color = "#FFFFFF",
    button_primary_background_fill_hover = "linear-gradient(90deg,#52A6AA,#3E67B7)",
    button_primary_text_color_hover = "#FFFFFF",
    
    button_secondary_background_fill = "#BDE0F9",
    button_secondary_background_fill_hover = "#EDEFF0",
    button_secondary_text_color_hover = "#4888D8",
    
    block_border_width = "1.5px",
    block_border_color = "#3E67B7",
    
    block_radius = "0",
    block_label_text_size = '12px',
    input_text_size = '5px',

    panel_border_color = "#EDEFF0",
)

gui = gr.Interface (
    theme = theme1,
    fn = ejecutar_modelo, 
    inputs = gr.Image (label='Imagen'), 
    outputs = [gr.Label(label='Contraste o armonía:',elem_id = 'labelitem'), 
               gr.Label(label='Inestabilidad o equilibrio:'),
               gr.Label(label='Fragmentación o unidad:'),
               gr.Label(label='Difusividad o agudeza:')],
    #title ='Evaluador de imágenes usando IA', 
)

gui.launch(inbrowser = True)


# In[ ]: