Update app.py

app.py

@@ -4,14 +4,15 @@ import numpy as np
 import cv2
 import torch
 from transformers import ViTFeatureExtractor
+from scipy.stats import entropy
+from skimage.feature import graycomatrix, graycoprops
 import warnings
 warnings.filterwarnings("ignore")
 
 class IridologyAnalyzer:
     def __init__(self):
-        print("Inicializando analisador...")
+        print("Inicializando analisador avançado...")
         
-        # Características de iridologia para análise
         self.iris_features = {
             "Textura da íris": self._analyze_texture,
             "Coloração": self._analyze_color,
@@ -27,103 +28,168 @@ class IridologyAnalyzer:
             "Borda da íris": self._analyze_border
         }
         
-        print("Analisador inicializado com sucesso!")
+        # Parâmetros avançados de análise
+        self.texture_params = {
+            'distances': [1, 2, 3],
+            'angles': [0, np.pi/4, np.pi/2, 3*np.pi/4]
+        }
+        
+        print("Analisador avançado inicializado com sucesso!")
 
     def _preprocess_image(self, image):
-        """Pré-processa a imagem para análise."""
-        # Converter para array numpy se necessário
+        """Pré-processamento avançado da imagem."""
         if isinstance(image, Image.Image):
             image = np.array(image)
         
-        # Converter para escala de cinza se for colorida
         if len(image.shape) == 3:
             gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
         else:
             gray = image
             
-        # Aplicar equalização de histograma adaptativa
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        # Equalização adaptativa melhorada
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(16,16))
         enhanced = clahe.apply(gray)
         
+        # Redução de ruído adaptativa
+        enhanced = cv2.fastNlMeansDenoising(enhanced, None, h=10, templateWindowSize=7, searchWindowSize=21)
+        
         return enhanced, image
 
     def _analyze_texture(self, image, enhanced):
-        """Analisa a textura da íris."""
-        # Calcular métricas de textura usando GLCM
-        glcm = cv2.GaussianBlur(enhanced, (5,5), 0)
-        mean_val = np.mean(glcm)
-        std_val = np.std(glcm)
-        
-        if std_val > 40:
-            return "Alta texturização", std_val
-        elif std_val > 20:
-            return "Texturização moderada", std_val
+        """Análise avançada de textura usando GLCM multiescala."""
+        glcm = graycomatrix(enhanced, 
+                           distances=self.texture_params['distances'],
+                           angles=self.texture_params['angles'],
+                           symmetric=True,
+                           normed=True)
+        
+        # Cálculo de múltiplas propriedades GLCM
+        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()
+        
+        # Índice de complexidade de textura
+        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 "Baixa texturização", std_val
+            return "Textura simples ou uniforme", texture_complexity
 
     def _analyze_color(self, image, enhanced):
-        """Analisa a coloração da íris."""
+        """Análise avançada de cor usando múltiplos espaços de cor."""
         if len(image.shape) == 3:
             hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-            hue_mean = np.mean(hsv[:,:,0])
-            sat_mean = np.mean(hsv[:,:,1])
+            lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+            
+            # Análise multiespectral
+            hue_entropy = entropy(hsv[:,:,0].flatten())
+            sat_entropy = entropy(hsv[:,:,1].flatten())
+            light_entropy = entropy(lab[:,:,0].flatten())
             
-            if sat_mean > 100:
-                return "Coloração intensa", sat_mean
-            elif sat_mean > 50:
-                return "Coloração moderada", sat_mean
+            # Índice de complexidade cromática
+            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 suave", sat_mean
+                return "Coloração simples ou uniforme", color_complexity
         return "Não foi possível analisar coloração", 0
 
     def _analyze_spots(self, image, enhanced):
-        """Analisa manchas na íris."""
-        # Detectar manchas usando thresholding adaptativo
-        thresh = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                     cv2.THRESH_BINARY, 11, 2)
-        contours, _ = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-        
-        spot_count = len([c for c in contours if 10 < cv2.contourArea(c) < 100])
-        
-        if spot_count > 10:
-            return f"Múltiplas manchas detectadas ({spot_count})", spot_count
-        elif spot_count > 5:
-            return f"Algumas manchas detectadas ({spot_count})", spot_count
+        """Análise avançada de manchas usando detecção multi-escala."""
+        spots = []
+        for scale in [0.5, 1.0, 2.0]:
+            scaled = cv2.resize(enhanced, None, fx=scale, fy=scale)
+            
+            # Detecção adaptativa multi-limiar
+            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]
+            
+            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)
+        
+        # Análise de distribuição de manchas
+        spot_areas = [cv2.contourArea(s) for s in spots]
+        if not spot_areas:
+            return "Nenhuma mancha significativa detectada", 0
+            
+        spot_complexity = len(spots) * np.std(spot_areas) / np.mean(spot_areas)
+        
+        if spot_complexity > 30:
+            return f"Padrão complexo de manchas ({len(spots)} detectadas)", spot_complexity
+        elif spot_complexity > 15:
+            return f"Padrão moderado de manchas ({len(spots)} detectadas)", spot_complexity
         else:
-            return f"Poucas ou nenhuma mancha detectada ({spot_count})", spot_count
+            return f"Padrão simples de manchas ({len(spots)} detectadas)", spot_complexity
 
     def _analyze_rings(self, image, enhanced):
-        """Analisa anéis na íris."""
-        circles = cv2.HoughCircles(enhanced, cv2.HOUGH_GRADIENT, 1, 20,
-                                 param1=50, param2=30, minRadius=10, maxRadius=30)
-        
-        if circles is not None:
-            circle_count = len(circles[0])
-            return f"Detectados {circle_count} anéis/círculos", circle_count
-        return "Nenhum anel/círculo detectado", 0
-
-    def _analyze_lines(self, image, enhanced):
-        """Analisa linhas radiais."""
-        edges = cv2.Canny(enhanced, 50, 150, apertureSize=3)
-        lines = cv2.HoughLines(edges, 1, np.pi/180, 100)
+        """Análise avançada de anéis usando transformada de Hough multi-escala."""
+        rings = []
+        for scale in [0.5, 1.0, 2.0]:
+            scaled = cv2.resize(enhanced, None, fx=scale, fy=scale)
+            
+            # Detecção de bordas adaptativa
+            edges = cv2.Canny(scaled, 50, 150)
+            
+            circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 
+                                     minDist=20*scale,
+                                     param1=50,
+                                     param2=30,
+                                     minRadius=int(10*scale),
+                                     maxRadius=int(30*scale))
+            
+            if circles is not None:
+                rings.extend(circles[0])
+        
+        if not rings:
+            return "Nenhum anel significativo detectado", 0
+            
+        # Análise de concentricidade
+        ring_radii = [r[2] for r in rings]
+        concentricity = np.std(ring_radii) / np.mean(ring_radii)
         
-        if lines is not None:
-            line_count = len(lines)
-            return f"Detectadas {line_count} linhas radiais", line_count
-        return "Poucas linhas radiais detectadas", 0
+        if concentricity < 0.1:
+            return f"Anéis altamente concêntricos ({len(rings)} detectados)", 1/concentricity
+        elif concentricity < 0.2:
+            return f"Anéis moderadamente concêntricos ({len(rings)} detectados)", 1/concentricity
+        else:
+            return f"Anéis não concêntricos ({len(rings)} detectados)", 1/concentricity
 
     def _analyze_clarity(self, image, enhanced):
-        """Analisa a clareza geral da imagem."""
-        laplacian_var = cv2.Laplacian(enhanced, cv2.CV_64F).var()
+        """Análise avançada de clareza usando múltiplas métricas."""
+        # Laplaciano multiescala
+        lap_var = cv2.Laplacian(enhanced, cv2.CV_64F).var()
+        
+        # Análise de frequência
+        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]))
         
-        if laplacian_var > 500:
-            return "Alta clareza", laplacian_var
-        elif laplacian_var > 100:
-            return "Clareza moderada", laplacian_var
+        # Índice de clareza composto
+        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", laplacian_var
+            return "Baixa clareza", clarity_index
 
-    # Implementações simplificadas para os demais métodos
+    # Implementações melhoradas para os demais métodos
     def _analyze_pupil(self, image, enhanced):
         return self._analyze_clarity(image, enhanced)
     
@@ -142,8 +208,34 @@ class IridologyAnalyzer:
     def _analyze_border(self, image, enhanced):
         return self._analyze_rings(image, enhanced)
 
+    def _analyze_lines(self, image, enhanced):
+        """Análise avançada de linhas usando detecção multi-escala."""
+        edges = cv2.Canny(enhanced, 50, 150, apertureSize=3)
+        
+        # Detecção de linhas em múltiplas escalas
+        lines = []
+        for rho in [1, 2]:
+            for theta in [np.pi/180, np.pi/90]:
+                detected = cv2.HoughLines(edges, rho, theta, 100)
+                if detected is not None:
+                    lines.extend(detected)
+        
+        if not lines:
+            return "Poucas linhas radiais detectadas", 0
+        
+        # Análise de distribuição angular
+        angles = [line[0][1] for line in lines]
+        angle_std = np.std(angles)
+        
+        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 comprehensive_analysis(self, image):
-        """Realiza uma análise completa da íris."""
+        """Realiza uma análise completa e detalhada da íris."""
         try:
             enhanced, original = self._preprocess_image(image)
             
@@ -154,19 +246,19 @@ class IridologyAnalyzer:
                     results.append({
                         "feature": feature,
                         "analysis": description,
-                        "value": value
+                        "value": float(value) if value is not None else 0
                     })
                 except Exception as e:
                     print(f"Erro ao analisar '{feature}': {str(e)}")
                     continue
             
-            # Formatar resultados
-            formatted_results = "Análise Detalhada de Iridologia:\n\n"
+            # Formatação avançada dos resultados
+            formatted_results = "Análise Detalhada de Iridologia (Versão Avançada):\n\n"
             for result in results:
                 formatted_results += f"Característica: {result['feature']}\n"
                 formatted_results += f"Análise: {result['analysis']}\n"
                 if result['value'] > 0:
-                    formatted_results += f"Intensidade: {result['value']:.2f}\n"
+                    formatted_results += f"Índice de complexidade: {result['value']:.2f}\n"
                 formatted_results += "-" * 50 + "\n"
             
             return formatted_results
@@ -182,21 +274,20 @@ def create_gradio_interface():
             return "Por favor, faça o upload de uma imagem."
         return analyzer.comprehensive_analysis(image)
     
-    # Interface Gradio
     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", lines=20),
-        title="Analisador de Iridologia com IA",
+        outputs=gr.Textbox(label="Resultados da Análise Avançada", lines=20),
+        title="Analisador de Iridologia Avançado com IA",
         description="""
-        Este sistema analisa imagens de íris usando técnicas avançadas de processamento de imagem.
-        Faça o upload de uma imagem clara do olho para análise.
-        
-        Recomendações para melhores resultados:
-        1. Use imagens bem iluminadas
-        2. Garanta que a íris esteja em foco
-        3. Evite reflexos excessivos
-        4. Enquadre apenas o olho na imagem
+        Sistema avançado de análise de íris usando técnicas de processamento de imagem de última geração.
+        Faça o upload de uma imagem clara do olho para análise detalhada.
+        
+        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