Update app.py

app.py

@@ -7,19 +7,67 @@ from typing import Tuple, Dict, List
 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
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('iridology_analyzer.log'),
+        logging.StreamHandler()
+    ]
+)
 
 @dataclass
 class IrisZone:
+    """Classe para definir as características de uma zona da íris"""
     name: str
     inner_ratio: float
     outer_ratio: float
     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"""
     def __init__(self):
-        # Define zonas com cores distintas e ângulos específicos
         self.zones = [
             IrisZone("Zona Cerebral/Neural", 0.85, 1.0, (255, 0, 0)),
             IrisZone("Zona Digestiva", 0.7, 0.85, (0, 255, 0)),
@@ -29,166 +77,320 @@ 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 melhorar a detecção"""
-        # Converter para escala de cinza
-        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-        
-        # Aplicar equalização de histograma adaptativo
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-        enhanced = clahe.apply(gray)
-        
-        # Redução de ruído
-        denoised = cv2.fastNlMeansDenoising(enhanced)
-        
-        return denoised
+        """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 usando técnicas avançadas"""
-        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)
-        
-        # Encontrar contornos
-        contours, _ = cv2.findContours(morph, cv2.RETR_EXTERNAL, 
-                                     cv2.CHAIN_APPROX_SIMPLE)
-        
-        if not contours:
-            return None
-        
-        # Encontrar o contorno mais circular
-        max_circularity = 0
-        best_contour = None
-        
-        for contour in contours:
-            area = cv2.contourArea(contour)
-            perimeter = cv2.arcLength(contour, True)
+        """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)
+            
+            # Encontrar contornos
+            contours, _ = cv2.findContours(morph, cv2.RETR_EXTERNAL, 
+                                         cv2.CHAIN_APPROX_SIMPLE)
             
-            if perimeter == 0:
-                continue
+            if not contours:
+                logging.warning("Nenhum contorno encontrado na imagem")
+                return None
+            
+            # Encontrar o contorno mais circular
+            max_circularity = 0
+            best_contour = None
+            
+            for contour in contours:
+                area = cv2.contourArea(contour)
+                perimeter = cv2.arcLength(contour, True)
                 
-            circularity = 4 * np.pi * area / (perimeter * perimeter)
+                if perimeter == 0:
+                    continue
+                    
+                circularity = 4 * np.pi * area / (perimeter * perimeter)
+                
+                if circularity > max_circularity:
+                    max_circularity = circularity
+                    best_contour = contour
             
-            if circularity > max_circularity:
-                max_circularity = circularity
-                best_contour = contour
-        
-        if best_contour is None:
-            return None
+            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))
             
-        # Ajustar círculo
-        (x, y), radius = cv2.minEnclosingCircle(best_contour)
-        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 da zona usando a máscara"""
-        # Extrair características da região
-        mean_color = cv2.mean(img, mask=mask)
-        
-        # Calcular textura usando GLCM
-        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
-        zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
-        
-        # Análise de textura básica
-        if np.sum(mask) > 0:
-            std_dev = np.std(zone_pixels[mask > 0])
-            mean_intensity = np.mean(zone_pixels[mask > 0])
-        else:
-            std_dev = 0
-            mean_intensity = 0
-        
-        return {
-            'mean_intensity': mean_intensity,
-            'std_dev': std_dev,
-            'color_variation': mean_color[:3]
-        }
+        """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"""
-        intensity = analysis['mean_intensity']
-        variation = analysis['std_dev']
-        
-        if intensity < 85:
-            base_condition = "Possível área de atenção"
-        elif intensity < 170:
-            base_condition = "Área moderada"
-        else:
-            base_condition = "Área normal"
-            
-        detail = f"(Intensidade: {intensity:.1f}, Variação: {variation:.1f})"
-        return f"{base_condition} {detail}"
+        """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
 
     def analyze_iris(self, img: np.ndarray) -> Tuple[np.ndarray, Dict]:
         """Análise principal da íris"""
-        # 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"}
+        try:
+            # Criar cópia para desenho
+            output_img = img.copy()
+            results = {}
             
-        x, y, pupil_radius = pupil
-        
-        # Estimar raio da íris (aproximadamente 4x o raio da pupila)
-        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
-            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
-            
-            # Adicionar texto
-            text_x = x - iris_radius
-            text_y = y + outer_r
-            cv2.putText(output_img, zone.name, (text_x, text_y),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, zone.color, 1)
-        
-        return output_img, 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
+                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
+                
+                # Adicionar texto
+                text_x = x - iris_radius
+                text_y = y + outer_r
+                cv2.putText(output_img, zone.name, (text_x, text_y),
+                           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)}"}
 
 def process_image(img):
-    analyzer = IrisAnalyzer()
-    return analyzer.analyze_iris(np.array(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)}
 
 # Interface Gradio
-iface = gr.Interface(
-    fn=process_image,
-    inputs=gr.Image(),
-    outputs=[
-        gr.Image(label="Análise Visual"),
-        gr.JSON(label="Resultados da Análise por Zona")
-    ],
-    title="Analisador Avançado de Íris (Baseado na Teoria de Jensen)",
-    description="""AVISO: Esta é uma demonstração educacional baseada na teoria de iridologia.
-    Esta não é uma ferramenta diagnóstica validada cientificamente e não deve ser usada para
-    decisões médicas. Consulte sempre um profissional de saúde qualificado para diagnósticos.""",
-    examples=[],
-    theme="default"
-)
+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.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(
+                label="Carregue a imagem do olho",
+                type="numpy",
+                tool="select",
+                height=300
+            )
+            
+            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
+            """)
+            
+        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
+        """)
+    
+    # Configurar o fluxo de análise
+    analyze_btn.click(
+        fn=process_image,
+        inputs=input_image,
+        outputs=[output_image, results],
+    )
+    
+    # Adicionar informações extras
+    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.
+    
+    ---
+    """)
 
 if __name__ == "__main__":
-    iface.launch()
+    # Criar diretório de logs se não existir
+    if not os.path.exists('logs'):
+        os.makedirs('logs')
+    
+    # Configurar nome do arquivo de log com timestamp
+    log_filename = f'logs/iridology_analyzer_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
+    
+    # Adicionar handler de arquivo para logs
+    file_handler = logging.FileHandler(log_filename)
+    file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logging.getLogger().addHandler(file_handler)
+    
+    # Iniciar a interface
+    try:
+        iface.launch(
+            share=True,             # Permite compartilhamento via link
+            server_name="0.0.0.0",  # Permite acesso externo
+            server_port=7860,       # Porta padrão do Gradio
+            enable_queue=True,      # Habilita fila para múltiplos usuários
+            auth=None,              # Sem autenticação
+            max_threads=4,          # Limite de threads
+            show_error=True         # Mostra erros detalhados
+        )
+        logging.info("Aplicação iniciada com sucesso")
+    except Exception as e:
+        logging.error(f"Erro ao iniciar a aplicação: {str(e)}")
+        raise