Update app.py

app.py

@@ -3,86 +3,60 @@ import tensorflow as tf
 import numpy as np
 from PIL import Image
 import cv2
-import datetime  # Importe o módulo datetime
-
-# Defina a camada personalizada FixedDropout
-class FixedDropout(tf.keras.layers.Dropout):
-    def _get_noise_shape(self, inputs):
-        if self.noise_shape is None:
-            return self.noise_shape
-        symbolic_shape = tf.shape(inputs)
-        noise_shape = [symbolic_shape[axis] if shape is None else shape
-                       for axis, shape in enumerate(self.noise_shape)]
-        return tuple(noise_shape)
-
-# Registre a camada personalizada FixedDropout
-tf.keras.utils.get_custom_objects()['FixedDropout'] = FixedDropout
-
-# Carregue seu modelo TensorFlow treinado
-with tf.keras.utils.custom_object_scope({'FixedDropout': FixedDropout}):
-    model = tf.keras.models.load_model('modelo_treinado.h5')
-
-# Defina uma função para fazer previsões
-def classify_image(input_image):
-    # Log da forma da entrada
-    print(f"Forma da entrada: {input_image.shape}")
-
-    # Redimensione a imagem para as dimensões corretas (192x256)
-    input_image = tf.image.resize(input_image, (192, 256))  # Redimensione para as dimensões esperadas
-    input_image = (input_image / 255.0)  # Normalize para [0, 1]
-    input_image = np.expand_dims(input_image, axis=0)  # Adicione a dimensão de lote
-
-    # Log da forma da entrada após o redimensionamento
-    print(f"Forma da entrada após o redimensionamento: {input_image.shape}")
-
-    # Obtenha o tempo atual
-    current_time = datetime.datetime.now()
-
-    # Faça a previsão usando o modelo
-    prediction = model.predict(input_image)
-
-    # Assumindo que o modelo retorna probabilidades para duas classes, você pode retornar a classe com a maior probabilidade
-    class_index = np.argmax(prediction)
-    class_labels = ["Normal", "Cataract"]  # Substitua pelas suas etiquetas de classe reais
-    predicted_class = class_labels[class_index]
-
-    # Crie uma imagem composta com o rótulo de previsão
-    output_image = (input_image[0] * 255).astype('uint8')
-
-    # Adicione espaço para o rótulo de previsão na parte inferior da imagem
-    output_image = cv2.copyMakeBorder(output_image, 0, 50, 0, 0, cv2.BORDER_CONSTANT, value=(255, 255, 255))
-
-    # Desenhe um retângulo branco como fundo para o rótulo
-    label_background = np.ones((50, output_image.shape[1], 3), dtype=np.uint8) * 255
-
-    # Coloque o texto do rótulo e a caixa dentro do fundo branco
-    output_image[-50:] = label_background
-
-    # Escreva o rótulo de previsão na imagem
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    font_scale = 0.4  # Tamanho da fonte reduzido
-    cv2.putText(output_image, f"Analysis Time: {current_time.strftime('%Y-%m-%d %H:%M:%S')}", (10, output_image.shape[0] - 30), font, font_scale, (0, 0, 0), 1)
-    cv2.putText(output_image, f"Predicted Class: {predicted_class}", (10, output_image.shape[0] - 10), font, font_scale, (0, 0, 0), 1)  # Cor preta
-
-    # Calcule as coordenadas para centralizar a caixa azul no centro da imagem
-    image_height, image_width, _ = output_image.shape
-    box_size = 100  # Tamanho da caixa azul (ajuste conforme necessário)
-    box_x = (image_width - box_size) // 2
-    box_y = (image_height - box_size) // 2
-
-    # Desenhe uma caixa de identificação de objeto (retângulo azul) centralizada
-    object_box_color = (255, 0, 0)  # Azul (BGR)
-    cv2.rectangle(output_image, (box_x, box_y), (box_x + box_size, box_y + box_size), object_box_color, 2)  # Caixa centralizada
-
-    return output_image
-
-# Crie uma interface Gradio
-input_interface = gr.Interface(
-    fn=classify_image,
-    inputs="image",  # Especifique o tipo de entrada como "image"
-    outputs="image",  # Especifique o tipo de saída como "image"
-    live=True
-)
-
-# Inicie o aplicativo Gradio
-input_interface.launch()
+import datetime
+
+class ImageClassifierApp:
+    def __init__(self, model_path):
+        self.model_path = model_path
+        self.model = self.load_model()
+        self.class_labels = ["Normal", "Cataract"]
+
+    def load_model(self):
+        # Load the trained TensorFlow model
+        with tf.keras.utils.custom_object_scope({'FixedDropout': FixedDropout}):
+            model = tf.keras.models.load_model(self.model_path)
+        return model
+
+    def classify_image(self, input_image):
+        input_image = tf.image.resize(input_image, (192, 256))
+        input_image = (input_image / 255.0)
+        input_image = np.expand_dims(input_image, axis=0)
+
+        current_time = datetime.datetime.now()
+        prediction = self.model.predict(input_image)
+        class_index = np.argmax(prediction)
+        predicted_class = self.class_labels[class_index]
+
+        output_image = (input_image[0] * 255).astype('uint8')
+        output_image = cv2.copyMakeBorder(output_image, 0, 50, 0, 0, cv2.BORDER_CONSTANT, value=(255, 255, 255))
+        label_background = np.ones((50, output_image.shape[1], 3), dtype=np.uint8) * 255
+        output_image[-50:] = label_background
+
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 0.4
+        cv2.putText(output_image, f"Analysis Time: {current_time.strftime('%Y-%m-%d %H:%M:%S')}", (10, output_image.shape[0] - 30), font, font_scale, (0, 0, 0), 1)
+        cv2.putText(output_image, f"Predicted Class: {predicted_class}", (10, output_image.shape[0] - 10), font, font_scale, (0, 0, 0), 1)
+
+        image_height, image_width, _ = output_image.shape
+        box_size = 100
+        box_x = (image_width - box_size) // 2
+        box_y = (image_height - box_size) // 2
+        object_box_color = (255, 0, 0)
+        cv2.rectangle(output_image, (box_x, box_y), (box_x + box_size, box_y + box_size), object_box_color, 2)
+
+        return output_image
+
+    def run_interface(self):
+        input_interface = gr.Interface(
+            fn=self.classify_image,
+            inputs="image",
+            outputs="image",
+            live=True
+        )
+        input_interface.launch()
+
+
+if __name__ == "__main__":
+    model_path = 'modelo_treinado.h5'  # Substitua pelo caminho para o seu modelo treinado
+    app = ImageClassifierApp(model_path)
+    app.run_interface()