app.py

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

# # 1. Pre-procesamiento de datos

# In[14]:


import cv2
import numpy as np


# In[15]:


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[16]:


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[17]:


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[18]:


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')


# In[27]:


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']
    
    return clase1 [resultado1], clase2 [resultado2], clase3 [resultado3], clase4 [resultado4]


# In[28]:


gui = gr.Interface (
    fn = ejecutar_modelo, 
    inputs = gr.Image (), 
    outputs = ["text", "text", "text", "text"],
    title ='Evaluador de imagenes usando IA', 
)

gui.launch(inbrowser = True)


# In[ ]:





# In[ ]: