Update app.py

app.py

@@ -1,222 +1,194 @@
 import gradio as gr
-from PIL import Image
-import numpy as np
 import cv2
+import numpy as np
+from PIL import Image
+from dataclasses import dataclass
+from typing import Tuple, Dict, List
 import torch
-from transformers import ViTFeatureExtractor
-from scipy.stats import entropy
-from skimage.feature import graycomatrix, graycoprops
-import warnings
-warnings.filterwarnings("ignore")
-
-class IridologyAnalyzer:
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+
+@dataclass
+class IrisZone:
+    name: str
+    inner_ratio: float
+    outer_ratio: float
+    color: Tuple[int, int, int]
+    angle_start: float = 0
+    angle_end: float = 360
+
+class IrisAnalyzer:
     def __init__(self):
-        print("Inicializando analisador avançado...")
+        # 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)),
+            IrisZone("Zona Respiratória", 0.55, 0.7, (0, 0, 255)),
+            IrisZone("Zona Circulatória", 0.4, 0.55, (255, 255, 0)),
+            IrisZone("Zona Linfática", 0.25, 0.4, (255, 0, 255)),
+            IrisZone("Zona Endócrina", 0.15, 0.25, (0, 255, 255)),
+            IrisZone("Zona Pupilar", 0, 0.15, (128, 128, 128))
+        ]
+        
+    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)
         
-        # [Previous initialization code remains the same...]
+        # Redução de ruído
+        denoised = cv2.fastNlMeansDenoising(enhanced)
         
-    def _preprocess_image(self, image):
-        """Pré-processamento da imagem."""
-        if isinstance(image, Image.Image):
-            image = np.array(image)
+        return denoised
+
+    def detect_pupil(self, img: np.ndarray) -> Tuple[int, int, int]:
+        """Detecta a pupila usando técnicas avançadas"""
+        preprocessed = self.preprocess_image(img)
         
-        if len(image.shape) == 3:
-            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        else:
-            gray = image
-            
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(16,16))
-        enhanced = clahe.apply(gray)
-        enhanced = cv2.fastNlMeansDenoising(enhanced, None, h=10, templateWindowSize=7, searchWindowSize=21)
+        # Threshold adaptativo
+        _, thresh = cv2.threshold(preprocessed, 30, 255, 
+                                cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
         
-        return enhanced, image
-
-    def _analyze_texture(self, image, enhanced):
-        """Análise de textura usando GLCM."""
-        glcm = graycomatrix(enhanced, 
-                           distances=[1, 2, 3],
-                           angles=[0, np.pi/4, np.pi/2, 3*np.pi/4],
-                           symmetric=True,
-                           normed=True)
-        
-        contrast = graycoprops(glcm, 'contrast').mean()
-        dissimilarity = graycoprops(glcm, 'dissimilarity').mean()
-        homogeneity = graycoprops(glcm, 'homogeneity').mean()
-        energy = graycoprops(glcm, 'energy').mean()
-        correlation = graycoprops(glcm, 'correlation').mean()
-        
-        texture_complexity = (contrast * dissimilarity) / (homogeneity * energy)
-        
-        if texture_complexity > 100:
-            return "Textura muito complexa e detalhada", texture_complexity
-        elif texture_complexity > 50:
-            return "Textura moderadamente complexa", texture_complexity
-        else:
-            return "Textura simples ou uniforme", texture_complexity
-
-    def _analyze_color(self, image, enhanced):
-        """Análise de cor."""
-        if len(image.shape) == 3:
-            hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-            lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
-            
-            hue_entropy = entropy(hsv[:,:,0].flatten())
-            sat_entropy = entropy(hsv[:,:,1].flatten())
-            light_entropy = entropy(lab[:,:,0].flatten())
-            
-            color_complexity = (hue_entropy * sat_entropy * light_entropy) ** (1/3)
-            
-            if color_complexity > 4:
-                return "Coloração muito rica e complexa", color_complexity
-            elif color_complexity > 2:
-                return "Coloração moderadamente complexa", color_complexity
-            else:
-                return "Coloração simples ou uniforme", color_complexity
-        return "Não foi possível analisar coloração", 0
-
-    def _analyze_spots(self, image, enhanced):
-        """Análise de manchas."""
-        spots = []
-        for scale in [0.5, 1.0, 2.0]:
-            scaled = cv2.resize(enhanced, None, fx=scale, fy=scale)
+        # 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)
             
-            local_thresh = cv2.adaptiveThreshold(scaled, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                               cv2.THRESH_BINARY, 11, 2)
-            global_thresh = cv2.threshold(scaled, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
+            if perimeter == 0:
+                continue
+                
+            circularity = 4 * np.pi * area / (perimeter * perimeter)
             
-            combined = cv2.bitwise_and(local_thresh, global_thresh)
-            contours, _ = cv2.findContours(combined, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-            valid_spots = [c for c in contours if 10*scale < cv2.contourArea(c) < 100*scale]
-            spots.extend(valid_spots)
+            if circularity > max_circularity:
+                max_circularity = circularity
+                best_contour = contour
         
-        if not spots:
-            return "Nenhuma mancha significativa detectada", 0
+        if best_contour is None:
+            return None
             
-        spot_complexity = len(spots) * np.std([cv2.contourArea(s) for s in spots])
-        
-        if spot_complexity > 1000:
-            return f"Padrão complexo de manchas ({len(spots)} detectadas)", spot_complexity
-        elif spot_complexity > 500:
-            return f"Padrão moderado de manchas ({len(spots)} detectadas)", spot_complexity
+        # Ajustar círculo
+        (x, y), radius = cv2.minEnclosingCircle(best_contour)
+        return (int(x), int(y), int(radius))
+
+    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:
-            return f"Padrão simples de manchas ({len(spots)} detectadas)", spot_complexity
-
-    def _analyze_rings(self, image, enhanced):
-        """Análise de anéis."""
-        circles = cv2.HoughCircles(enhanced, cv2.HOUGH_GRADIENT, 1, 
-                                 minDist=20,
-                                 param1=50,
-                                 param2=30,
-                                 minRadius=10,
-                                 maxRadius=30)
-        
-        if circles is None:
-            return "Nenhum anel significativo detectado", 0
-            
-        circles = np.uint16(np.around(circles[0]))
-        concentricity = np.std([c[2] for c in circles]) / np.mean([c[2] for c in circles])
-        
-        if concentricity < 0.1:
-            return f"Anéis altamente concêntricos ({len(circles)} detectados)", 1/concentricity
-        elif concentricity < 0.2:
-            return f"Anéis moderadamente concêntricos ({len(circles)} detectados)", 1/concentricity
+            std_dev = 0
+            mean_intensity = 0
+        
+        return {
+            'mean_intensity': mean_intensity,
+            'std_dev': std_dev,
+            'color_variation': mean_color[:3]
+        }
+
+    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:
-            return f"Anéis não concêntricos ({len(circles)} detectados)", 1/concentricity
-
-    def _analyze_pupil(self, image, enhanced):
-        """Análise da pupila."""
-        return self._analyze_clarity(image, enhanced)
-
-    def _analyze_lines(self, image, enhanced):
-        """Análise de linhas."""
-        edges = cv2.Canny(enhanced, 50, 150, apertureSize=3)
-        lines = cv2.HoughLines(edges, 1, np.pi/180, 100)
+            base_condition = "Área normal"
+            
+        detail = f"(Intensidade: {intensity:.1f}, Variação: {variation:.1f})"
+        return f"{base_condition} {detail}"
+
+    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"}
+            
+        x, y, pupil_radius = pupil
         
-        if lines is None:
-            return "Poucas linhas radiais detectadas", 0
+        # Estimar raio da íris (aproximadamente 4x o raio da pupila)
+        iris_radius = pupil_radius * 4
         
-        angles = [line[0][1] for line in lines]
-        angle_std = np.std(angles)
+        # Desenhar círculo da pupila
+        cv2.circle(output_img, (x, y), pupil_radius, (0, 0, 0), 2)
         
-        if angle_std < 0.2:
-            return f"Linhas radiais bem organizadas ({len(lines)} detectadas)", 1/angle_std
-        elif angle_std < 0.4:
-            return f"Linhas radiais moderadamente organizadas ({len(lines)} detectadas)", 1/angle_std
-        else:
-            return f"Linhas radiais irregulares ({len(lines)} detectadas)", 1/angle_std
-
-    def _analyze_pigmentation(self, image, enhanced):
-        """Análise de pigmentação."""
-        return self._analyze_color(image, enhanced)
-
-    def _analyze_clarity(self, image, enhanced):
-        """Análise de clareza."""
-        lap_var = cv2.Laplacian(enhanced, cv2.CV_64F).var()
-        dft = cv2.dft(np.float32(enhanced), flags=cv2.DFT_COMPLEX_OUTPUT)
-        dft_shift = np.fft.fftshift(dft)
-        magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0], dft_shift[:,:,1]))
-        
-        freq_energy = np.sum(magnitude_spectrum) / (enhanced.shape[0] * enhanced.shape[1])
-        clarity_index = np.sqrt(lap_var * freq_energy)
-        
-        if clarity_index > 1000:
-            return "Clareza excepcional", clarity_index
-        elif clarity_index > 500:
-            return "Alta clareza", clarity_index
-        elif clarity_index > 100:
-            return "Clareza moderada", clarity_index
-        else:
-            return "Baixa clareza", clarity_index
-
-    def _analyze_tissue(self, image, enhanced):
-        """Análise do tecido."""
-        return self._analyze_texture(image, enhanced)
-
-    def _analyze_white_marks(self, image, enhanced):
-        """Análise de marcas brancas."""
-        return self._analyze_spots(image, enhanced)
-
-    def _analyze_fibers(self, image, enhanced):
-        """Análise de fibras."""
-        return self._analyze_lines(image, enhanced)
-
-    def _analyze_border(self, image, enhanced):
-        """Análise da borda."""
-        return self._analyze_rings(image, enhanced)
-
-    # [Previous comprehensive_analysis method remains the same...]
-
-def create_gradio_interface():
-    analyzer = IridologyAnalyzer()
-    
-    def process_image(image):
-        if image is None:
-            return "Por favor, faça o upload de uma imagem."
-        return analyzer.comprehensive_analysis(image)
-    
-    iface = gr.Interface(
-        fn=process_image,
-        inputs=gr.Image(type="numpy", label="Upload da Imagem do Olho"),
-        outputs=gr.Textbox(label="Resultados da Análise Avançada", lines=30),
-        title="Analisador de Iridologia Avançado com IA",
-        description="""
-        Sistema avançado de análise de íris usando técnicas de processamento de imagem e correlações de saúde.
-        Faça o upload de uma imagem clara do olho para análise detalhada.
-        
-        IMPORTANTE: Esta ferramenta é apenas para fins educativos e NÃO substitui diagnóstico médico profissional.
-        
-        Recomendações para resultados otimizados:
-        1. Use imagens bem iluminadas e de alta resolução
-        2. Garanta que a íris esteja em foco perfeito
-        3. Evite reflexos e sombras
-        4. Enquadre apenas o olho na imagem, centralizando a íris
-        """,
-        examples=[],
-        cache_examples=True
-    )
-    
-    return iface
+        # 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
+
+def process_image(img):
+    analyzer = IrisAnalyzer()
+    return analyzer.analyze_iris(np.array(img))
+
+# 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"
+)
 
 if __name__ == "__main__":
-    iface = create_gradio_interface()
     iface.launch()