Hugging Face's logo

Spaces:
oomarsaldivar
/
TEVIS
Runtime error

App Files Community
TEVIS
File size: 3,194 Bytes 
46b8192
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
#!/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[ ]: