Update app.py

app.py

@@ -8,17 +8,12 @@ import torch
 import torch.nn.functional as F
 import torchvision.transforms as transforms
 import logging
-import os
 from datetime import datetime
 
-# Configuração de logging
+# Configuração básica de logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('iridology_analyzer.log'),
-        logging.StreamHandler()
-    ]
+    format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
 @dataclass
@@ -30,40 +25,6 @@ class IrisZone:
     color: Tuple[int, int, int]
     angle_start: float = 0
     angle_end: float = 360
-    
-    def __post_init__(self):
-        """Validação dos parâmetros da zona"""
-        if not 0 <= self.inner_ratio <= 1:
-            raise ValueError("inner_ratio deve estar entre 0 e 1")
-        if not 0 <= self.outer_ratio <= 1:
-            raise ValueError("outer_ratio deve estar entre 0 e 1")
-        if self.inner_ratio >= self.outer_ratio:
-            raise ValueError("inner_ratio deve ser menor que outer_ratio")
-
-class ImageProcessor:
-    """Classe para processamento básico de imagens"""
-    @staticmethod
-    def enhance_image(img: np.ndarray) -> np.ndarray:
-        """Melhora a qualidade da imagem"""
-        # Converter para LAB
-        lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
-        l, a, b = cv2.split(lab)
-        
-        # Aplicar CLAHE no canal L
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
-        l = clahe.apply(l)
-        
-        # Merge canais
-        lab = cv2.merge((l,a,b))
-        
-        # Converter de volta para RGB
-        enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
-        return enhanced
-    
-    @staticmethod
-    def reduce_noise(img: np.ndarray) -> np.ndarray:
-        """Reduz ruído na imagem"""
-        return cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
 
 class IrisAnalyzer:
     """Classe principal para análise da íris"""
@@ -77,311 +38,112 @@ class IrisAnalyzer:
             IrisZone("Zona Endócrina", 0.15, 0.25, (0, 255, 255)),
             IrisZone("Zona Pupilar", 0, 0.15, (128, 128, 128))
         ]
-        self.image_processor = ImageProcessor()
-        logging.info("IrisAnalyzer inicializado com %d zonas", len(self.zones))
-
-    def preprocess_image(self, img: np.ndarray) -> np.ndarray:
-        """Pré-processa a imagem para análise"""
-        try:
-            # Melhorar qualidade
-            enhanced = self.image_processor.enhance_image(img)
-            
-            # Reduzir ruído
-            denoised = self.image_processor.reduce_noise(enhanced)
-            
-            # Converter para escala de cinza
-            gray = cv2.cvtColor(denoised, cv2.COLOR_RGB2GRAY)
-            
-            # Equalização adaptativa
-            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-            preprocessed = clahe.apply(gray)
-            
-            logging.info("Pré-processamento de imagem concluído com sucesso")
-            return preprocessed
-        except Exception as e:
-            logging.error("Erro no pré-processamento: %s", str(e))
-            raise
 
     def detect_pupil(self, img: np.ndarray) -> Tuple[int, int, int]:
         """Detecta a pupila na imagem"""
         try:
-            preprocessed = self.preprocess_image(img)
-            
-            # Threshold adaptativo
-            _, thresh = cv2.threshold(preprocessed, 30, 255, 
-                                   cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-            
-            # Operações morfológicas
-            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
-            morph = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
+            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+            blur = cv2.GaussianBlur(gray, (5,5), 0)
+            _, thresh = cv2.threshold(blur, 30, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
             
-            # Encontrar contornos
-            contours, _ = cv2.findContours(morph, cv2.RETR_EXTERNAL, 
-                                         cv2.CHAIN_APPROX_SIMPLE)
+            contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
             
             if not contours:
-                logging.warning("Nenhum contorno encontrado na imagem")
                 return None
             
-            # Encontrar o contorno mais circular
-            max_circularity = 0
+            # Encontrar o maior contorno circular
+            max_area = 0
             best_contour = None
             
             for contour in contours:
                 area = cv2.contourArea(contour)
-                perimeter = cv2.arcLength(contour, True)
-                
-                if perimeter == 0:
-                    continue
-                    
-                circularity = 4 * np.pi * area / (perimeter * perimeter)
-                
-                if circularity > max_circularity:
-                    max_circularity = circularity
+                if area > max_area:
+                    max_area = area
                     best_contour = contour
             
             if best_contour is None:
-                logging.warning("Nenhum contorno circular encontrado")
                 return None
                 
-            # Ajustar círculo
             (x, y), radius = cv2.minEnclosingCircle(best_contour)
-            logging.info("Pupila detectada em (x=%d, y=%d) com raio=%d", 
-                        int(x), int(y), int(radius))
             return (int(x), int(y), int(radius))
             
         except Exception as e:
-            logging.error("Erro na detecção da pupila: %s", str(e))
-            raise
-
-    def analyze_zone(self, img: np.ndarray, mask: np.ndarray) -> Dict:
-        """Analisa características de uma zona específica"""
-        try:
-            # Extrair características da região
-            mean_color = cv2.mean(img, mask=mask)
-            
-            # Calcular textura
-            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-            zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
-            
-            if np.sum(mask) > 0:
-                std_dev = np.std(zone_pixels[mask > 0])
-                mean_intensity = np.mean(zone_pixels[mask > 0])
-                
-                # Calcular características adicionais
-                non_zero = zone_pixels[mask > 0]
-                percentiles = np.percentile(non_zero, [25, 50, 75])
-                
-                analysis = {
-                    'mean_intensity': mean_intensity,
-                    'std_dev': std_dev,
-                    'color_variation': mean_color[:3],
-                    'quartiles': percentiles.tolist(),
-                    'pixel_count': len(non_zero)
-                }
-            else:
-                analysis = {
-                    'mean_intensity': 0,
-                    'std_dev': 0,
-                    'color_variation': (0,0,0),
-                    'quartiles': [0,0,0],
-                    'pixel_count': 0
-                }
-            
-            return analysis
-            
-        except Exception as e:
-            logging.error("Erro na análise da zona: %s", str(e))
-            raise
-
-    def interpret_zone(self, analysis: Dict) -> str:
-        """Interpreta os resultados da análise de uma zona"""
-        try:
-            intensity = analysis['mean_intensity']
-            variation = analysis['std_dev']
-            
-            # Classificação básica
-            if intensity < 85:
-                base_condition = "Possível área de atenção"
-                confidence = "baixa" if variation > 30 else "média"
-            elif intensity < 170:
-                base_condition = "Área moderada"
-                confidence = "média" if variation > 20 else "alta"
-            else:
-                base_condition = "Área normal"
-                confidence = "alta" if variation < 15 else "média"
-            
-            # Adicionar detalhes estatísticos
-            detail = (f"(Intensidade: {intensity:.1f}, "
-                     f"Variação: {variation:.1f}, "
-                     f"Confiança: {confidence})")
-            
-            return f"{base_condition} {detail}"
-            
-        except Exception as e:
-            logging.error("Erro na interpretação da zona: %s", str(e))
-            raise
+            logging.error(f"Erro na detecção da pupila: {str(e)}")
+            return None
 
     def analyze_iris(self, img: np.ndarray) -> Tuple[np.ndarray, Dict]:
         """Análise principal da íris"""
         try:
-            # Criar cópia para desenho
             output_img = img.copy()
             results = {}
             
-            # Detectar pupila
             pupil = self.detect_pupil(img)
             if pupil is None:
                 return img, {"Erro": "Não foi possível detectar a pupila"}
                 
             x, y, pupil_radius = pupil
-            
-            # Estimar raio da íris
             iris_radius = pupil_radius * 4
             
-            # Desenhar círculo da pupila
             cv2.circle(output_img, (x, y), pupil_radius, (0, 0, 0), 2)
             
-            # Analisar cada zona
             for zone in self.zones:
                 inner_r = int(iris_radius * zone.inner_ratio)
                 outer_r = int(iris_radius * zone.outer_ratio)
                 
-                # Criar máscara para a zona
+                cv2.circle(output_img, (x, y), outer_r, zone.color, 2)
+                
+                # Análise simplificada da zona
                 mask = np.zeros(img.shape[:2], dtype=np.uint8)
                 cv2.circle(mask, (x, y), outer_r, 255, -1)
                 cv2.circle(mask, (x, y), inner_r, 0, -1)
                 
-                # Desenhar círculos da zona
-                cv2.circle(output_img, (x, y), outer_r, zone.color, 2)
-                
-                # Analisar zona
-                analysis = self.analyze_zone(img, mask)
-                interpretation = self.interpret_zone(analysis)
-                results[zone.name] = interpretation
+                mean_color = cv2.mean(img, mask=mask)
+                results[zone.name] = f"Intensidade média: {mean_color[0]:.1f}"
                 
-                # Adicionar texto
-                text_x = x - iris_radius
-                text_y = y + outer_r
-                cv2.putText(output_img, zone.name, (text_x, text_y),
+                # Adicionar rótulo
+                cv2.putText(output_img, zone.name, 
+                           (x - iris_radius, y + outer_r),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, zone.color, 1)
             
-            logging.info("Análise completa realizada com sucesso")
             return output_img, results
             
         except Exception as e:
-            logging.error("Erro na análise da íris: %s", str(e))
-            return img, {"Erro": f"Erro na análise: {str(e)}"}
+            logging.error(f"Erro na análise: {str(e)}")
+            return img, {"Erro": str(e)}
 
 def process_image(img):
-    """Função principal para processar imagem via Gradio"""
-    try:
-        analyzer = IrisAnalyzer()
-        return analyzer.analyze_iris(np.array(img))
-    except Exception as e:
-        logging.error("Erro no processamento da imagem: %s", str(e))
-        return img, {"Erro": str(e)}
+    """Função principal para processar imagem"""
+    if img is None:
+        return None, {"Erro": "Nenhuma imagem fornecida"}
+    analyzer = IrisAnalyzer()
+    return analyzer.analyze_iris(np.array(img))
 
-# Interface Gradio atualizada
+# Interface Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
-    # 🔍 Analisador Avançado de Íris
-    ### Baseado na teoria de Jensen para análise de zonas da íris
-    
-    ⚠️ **AVISO**: Esta é uma demonstração educacional. Não use para diagnósticos médicos.
+    # 🔍 Analisador de Íris
+    ### Análise de zonas da íris baseada na teoria de Jensen
     """)
     
     with gr.Row():
-        with gr.Column(scale=1):
-            # Corrigido o componente Image removendo o parâmetro 'tool'
+        with gr.Column():
             input_image = gr.Image(
-                label="Carregue a imagem do olho",
+                label="Upload da imagem do olho",
                 type="numpy",
-                height=300,
-                sources=["upload", "clipboard"]  # Especifica as fontes de entrada permitidas
+                sources=["upload", "clipboard"]
             )
             
-            analyze_btn = gr.Button(
-                "📸 Analisar Imagem", 
-                variant="primary",
-                scale=1
-            )
-            
-            gr.Markdown("""
-            ### Como usar:
-            1. Faça upload de uma imagem clara do olho
-            2. Certifique-se que a íris está bem visível
-            3. Clique em "Analisar Imagem"
-            4. Veja os resultados à direita
-            """)
+            analyze_btn = gr.Button("📸 Analisar", variant="primary")
             
-        with gr.Column(scale=1):
-            output_image = gr.Image(
-                label="Análise Visual",
-                height=300
-            )
-            
-            with gr.Accordion("📊 Resultados Detalhados", open=True):
-                results = gr.JSON(label="")
-                
-    with gr.Row():
-        gr.Markdown("""
-        ### Legenda das Zonas:
-        - 🔴 Zona Cerebral/Neural
-        - 🟢 Zona Digestiva
-        - 🔵 Zona Respiratória
-        - 🟡 Zona Circulatória
-        - 🟣 Zona Linfática
-        - 🔰 Zona Endócrina
-        - ⚪ Zona Pupilar
-        """)
+        with gr.Column():
+            output_image = gr.Image(label="Análise Visual")
+            results = gr.JSON(label="Resultados")
     
-    # Configurar o fluxo de análise
     analyze_btn.click(
         fn=process_image,
         inputs=input_image,
-        outputs=[output_image, results],
+        outputs=[output_image, results]
     )
-    
-    gr.Markdown("""
-    ---
-    ### ℹ️ Informações Importantes
-    
-    Este aplicativo utiliza técnicas avançadas de processamento de imagem para:
-    - Detectar automaticamente a pupila
-    - Segmentar as zonas da íris
-    - Analisar padrões de cor e textura
-    - Gerar relatório detalhado por zona
-    
-    **Recursos Técnicos:**
-    - Processamento de imagem adaptativo
-    - Detecção automática de pupila
-    - Análise de textura e padrões
-    - Sistema de logging para rastreamento
-    - Tratamento de erros robusto
-    
-    **Lembre-se**: A iridologia é considerada uma prática alternativa e não é reconhecida 
-    pela medicina convencional como método válido de diagnóstico.
-    """)
-
-# Configuração de logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler()
-    ]
-)
 
 if __name__ == "__main__":
-    try:
-        iface.launch(
-            share=True,
-            server_name="0.0.0.0",
-            server_port=7860,
-            enable_queue=True
-        )
-        logging.info("Aplicação iniciada com sucesso")
-    except Exception as e:
-        logging.error(f"Erro ao iniciar a aplicação: {str(e)}")
-        raise
+    iface.launch()