Update app.py

app.py

@@ -2,7 +2,7 @@ import gradio as gr
 import cv2
 import numpy as np
 from dataclasses import dataclass
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 from datetime import datetime
 
 @dataclass
@@ -10,7 +10,7 @@ class IrisZone:
     name: str
     ratio: Tuple[float, float]  # (inner, outer)
     color: Tuple[int, int, int]
-    conditions: Dict[str, List[str]]  # Detailed health conditions
+    conditions: Dict[str, List[str]]
     recommendations: Dict[str, List[str]]
 
 class IrisAnalyzer:
@@ -194,55 +194,92 @@ class IrisAnalyzer:
         ]
 
     def _assess_image_quality(self, image: np.ndarray) -> float:
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
-        brightness = np.mean(gray)
-        contrast = np.std(gray)
-        
-        quality_score = (
-            min(blur_score / 500, 1) * 0.4 +
-            min(abs(brightness - 128) / 128, 1) * 0.3 +
-            min(contrast / 50, 1) * 0.3
-        ) * 100
-        
-        return quality_score
+        """Assess image quality with better error handling."""
+        try:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
+            brightness = np.mean(gray)
+            contrast = np.std(gray)
+            
+            quality_score = (
+                np.clip(blur_score / 500, 0, 1) * 0.4 +
+                np.clip(1 - abs(brightness - 128) / 128, 0, 1) * 0.3 +
+                np.clip(contrast / 50, 0, 1) * 0.3
+            ) * 100
+            
+            return float(quality_score)
+        except Exception as e:
+            print(f"Error in image quality assessment: {str(e)}")
+            return 0.0
 
     def _analyze_texture(self, gray: np.ndarray, mask: np.ndarray) -> float:
-        zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
-        if np.sum(mask) == 0:
-            return 0
+        """Analyze texture with improved error handling and normalization."""
+        try:
+            if mask is None or np.sum(mask) == 0:
+                return 0.0
+                
+            zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
+            valid_pixels = zone_pixels[mask > 0]
             
-        mean = np.mean(zone_pixels[mask > 0])
-        std = np.std(zone_pixels[mask > 0])
-        entropy = np.sum(np.abs(np.diff(zone_pixels[mask > 0])))
-        
-        texture_score = (mean * 0.3 + std * 0.3 + min(entropy/1000, 1) * 0.4) * 100
-        return min(texture_score, 100)
+            if len(valid_pixels) == 0:
+                return 0.0
+                
+            mean = np.mean(valid_pixels)
+            std = np.std(valid_pixels)
+            entropy = np.sum(np.abs(np.diff(valid_pixels)))
+            
+            texture_score = (
+                np.clip(mean / 255, 0, 1) * 0.3 +
+                np.clip(std / 128, 0, 1) * 0.3 +
+                np.clip(entropy / 1000, 0, 1) * 0.4
+            ) * 100
+            
+            return float(texture_score)
+        except Exception as e:
+            print(f"Error in texture analysis: {str(e)}")
+            return 0.0
 
     def _analyze_contrast(self, l_channel: np.ndarray, mask: np.ndarray) -> float:
-        if np.sum(mask) == 0:
-            return 0
+        """Analyze contrast with improved error handling."""
+        try:
+            if mask is None or np.sum(mask) == 0:
+                return 0.0
+                
+            zone_pixels = l_channel[mask > 0]
+            if len(zone_pixels) == 0:
+                return 0.0
+                
+            p5 = np.percentile(zone_pixels, 5)
+            p95 = np.percentile(zone_pixels, 95)
             
-        zone_pixels = l_channel[mask > 0]
-        p5 = np.percentile(zone_pixels, 5)
-        p95 = np.percentile(zone_pixels, 95)
-        
-        contrast_score = ((p95 - p5) / 255) * 100
-        return min(contrast_score, 100)
+            contrast_score = np.clip((p95 - p5) / 255, 0, 1) * 100
+            return float(contrast_score)
+        except Exception as e:
+            print(f"Error in contrast analysis: {str(e)}")
+            return 0.0
 
     def _detect_patterns(self, gray: np.ndarray, mask: np.ndarray) -> float:
-        if np.sum(mask) == 0:
-            return 0
+        """Detect patterns with improved error handling."""
+        try:
+            if mask is None or np.sum(mask) == 0:
+                return 0.0
+                
+            sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+            sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+            gradient = np.sqrt(sobelx**2 + sobely**2)
             
-        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
-        sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
-        gradient = np.sqrt(sobelx**2 + sobely**2)
-        
-        zone_gradient = gradient[mask > 0]
-        pattern_score = (np.mean(zone_gradient) / np.max(gradient)) * 100
-        return min(pattern_score, 100)
+            zone_gradient = gradient[mask > 0]
+            if len(zone_gradient) == 0 or np.max(gradient) == 0:
+                return 0.0
+                
+            pattern_score = np.clip((np.mean(zone_gradient) / np.max(gradient)), 0, 1) * 100
+            return float(pattern_score)
+        except Exception as e:
+            print(f"Error in pattern detection: {str(e)}")
+            return 0.0
 
     def _customize_conditions(self, base_conditions: List[str], metrics: Dict) -> List[str]:
+        """Customize conditions based on metrics."""
         customized = []
         for condition in base_conditions:
             if metrics["intensity"] < 50:
@@ -257,6 +294,7 @@ class IrisAnalyzer:
         return customized
 
     def _customize_recommendations(self, base_recommendations: List[str], metrics: Dict) -> List[str]:
+        """Customize recommendations based on metrics."""
         customized = []
         for rec in base_recommendations:
             if metrics["texture"] < 40:
@@ -268,6 +306,7 @@ class IrisAnalyzer:
         return customized
 
     def _calculate_confidence(self, metrics: Dict) -> str:
+        """Calculate analysis confidence level."""
         confidence_score = (
             metrics["intensity"] * 0.25 +
             metrics["contrast"] * 0.25 +
@@ -282,148 +321,185 @@ class IrisAnalyzer:
         else:
             return "baixa"
 
-    def analyze_iris(self, image: np.ndarray) -> Dict:
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
-        
-        circles = cv2.HoughCircles(
-            gray, cv2.HOUGH_GRADIENT, dp=1, minDist=100,
-            param1=50, param2=30, minRadius=50, maxRadius=150
-        )
-        
-        if circles is not None:
-            circle = circles[0][0]
-            center = (int(circle[0]), int(circle[1]))
-            radius = int(circle[2])
-        else:
-            center = (image.shape[1]//2, image.shape[0]//2)
-            radius = min(image.shape[:2])//4
-        
-        results = {
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "analysis": {},
-            "metrics": {
-                "iris_radius": radius,
-                "image_quality": self._assess_image_quality(image)
-            }
-        }
-        
-        for zone in self.zones:
-            inner_r = int(radius * zone.ratio[0])
-            outer_r = int(radius * zone.ratio[1])
-            
-            mask = np.zeros(gray.shape, dtype=np.uint8)
-            cv2.circle(mask, center, outer_r, 255, -1)
-            cv2.circle(mask, center, inner_r, 0, -1)
+    def analyze_iris(self, image: np.ndarray) -> Tuple[np.ndarray, Dict]:
+        """Main analysis function with improved error handling and image processing."""
+        try:
+            # Convert BGR to RGB if needed
+            if len(image.shape) == 2:
+                image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+            elif image.shape[2] == 4:
+                image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)
             
-            zone_metrics = {
-                "intensity": cv2.mean(gray, mask=mask)[0],
-                "saturation": cv2.mean(hsv[..., 1], mask=mask)[0],
-                "texture": self._analyze_texture(gray, mask),
-                "contrast": self._analyze_contrast(lab[..., 0], mask),
-                "patterns": self._detect_patterns(gray, mask)
-            }
+            # Create copies for different color spaces
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+            lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
             
-            health_score = (
-                zone_metrics["intensity"] * 0.3 +
-                zone_metrics["saturation"] * 0.2 +
-                zone_metrics["texture"] * 0.2 +
-                zone_metrics["contrast"] * 0.15 +
-                zone_metrics["patterns"] * 0.15
+            # Improve circle detection
+            circles = cv2.HoughCircles(
+                gray,
+                cv2.HOUGH_GRADIENT,
+                dp=1,
+                minDist=max(gray.shape[0], gray.shape[1]),  # Only detect one circle
+                param1=50,
+                param2=30,
+                minRadius=min(gray.shape) // 6,
+                maxRadius=min(gray.shape) // 2
             )
             
-            if health_score < 40:
-                level = "baixa"
-            elif health_score < 75:
-                level = "media"
+            if circles is not None:
+                circles = np.uint16(np.around(circles))
+                circle = circles[0][0]
+                center = (int(circle[0]), int(circle[1]))
+                radius = int(circle[2])
             else:
-                level = "alta"
-                
-            results["analysis"][zone.name] = {
-                "conditions": self._customize_conditions(zone.conditions[level], zone_metrics),
-                "recommendations": self._customize_recommendations(zone.recommendations[level], zone_metrics),
+                # Fallback to image center if no circle is detected
+                center = (image.shape[1] // 2, image.shape[0] // 2)
+                radius = min(image.shape[:2]) // 4
+            
+            results = {
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "analysis": {},
                 "metrics": {
-                    "intensity": float(zone_metrics["intensity"]),
-                    "saturation": float(zone_metrics["saturation"]),
-                    "texture": float(zone_metrics["texture"]),
-                    "contrast": float(zone_metrics["contrast"]),
-                    "patterns": float(zone_metrics["patterns"]),
-                    "health_score": float(health_score)
-                },
-                "status": level,
-                "confianca_analise": self._calculate_confidence(zone_metrics)
+                    "iris_radius": radius,
+                    "image_quality": self._assess_image_quality(image)
+                }
             }
             
-            cv2.circle(image, center, outer_r, zone.color, 2)
-            cv2.putText(image, zone.name, 
-                       (center[0]-outer_r, center[1]+outer_r),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, zone.color, 1)
-        
-        return image, results
+            # Analysis for each zone
+            for zone in self.zones:
+                inner_r = int(radius * zone.ratio[0])
+                outer_r = int(radius * zone.ratio[1])
+                
+                # Create zone mask
+                mask = np.zeros(gray.shape, dtype=np.uint8)
+                cv2.circle(mask, center, outer_r, 255, -1)
+                cv2.circle(mask, center, inner_r, 0, -1)
+                
+                # Calculate metrics
+                zone_metrics = {
+                    "intensity": float(cv2.mean(gray, mask=mask)[0]),
+                    "saturation": float(cv2.mean(hsv[..., 1], mask=mask)[0]),
+                    "texture": self._analyze_texture(gray, mask),
+                    "contrast": self._analyze_contrast(lab[..., 0], mask),
+                    "patterns": self._detect_patterns(gray, mask)
+                }
+                
+                # Calculate health score
+                health_score = (
+                    zone_metrics["intensity"] * 0.3 +
+                    zone_metrics["saturation"] * 0.2 +
+                    zone_metrics["texture"] * 0.2 +
+                    zone_metrics["contrast"] * 0.15 +
+                    zone_metrics["patterns"] * 0.15
+                )
+                
+                # Determine health level
+                level = "baixa" if health_score < 40 else ("media" if health_score < 75 else "alta")
+                
+                # Store results
+                results["analysis"][zone.name] = {
+                    "conditions": self._customize_conditions(zone.conditions[level], zone_metrics),
+                    "recommendations": self._customize_recommendations(zone.recommendations[level], zone_metrics),
+                    "metrics": {k: float(v) for k, v in zone_metrics.items()},
+                    "health_score": float(health_score),
+                    "status": level,
+                    "confianca_analise": self._calculate_confidence(zone_metrics)
+                }
+                
+                # Draw zone visualization
+                cv2.circle(image, center, outer_r, zone.color, 2)
+                cv2.putText(
+                    image,
+                    zone.name,
+                    (center[0] - outer_r, center[1] + outer_r),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    zone.color,
+                    1,
+                    cv2.LINE_AA
+                )
+            
+            return image, results
+            
+        except Exception as e:
+            print(f"Error in iris analysis: {str(e)}")
+            return image, {"error": str(e)}
 
-def process_image(img):
+def process_image(img: Optional[np.ndarray]) -> Tuple[Optional[np.ndarray], str, str, str, str]:
+    """Process image with improved error handling and input validation."""
     if img is None:
-        return [None] * 5, gr.Warning("Por favor, carregue uma imagem.")
-    
-    analyzer = IrisAnalyzer()
-    processed_img, results = analyzer.analyze_iris(img)
-    
-    # Relatório Geral
-    general_report = "# 📊 Visão Geral da Análise\n\n"
-    status_counts = {"baixa": 0, "media": 0, "alta": 0}
-    for analysis in results["analysis"].values():
-        status_counts[analysis["status"]] += 1
-    
-    health_score = ((status_counts["alta"] * 100) + (status_counts["media"] * 50)) / len(results["analysis"])
-    general_report += f"**Índice de Saúde Geral:** {health_score:.1f}%\n\n"
-    general_report += f"**Data da Análise:** {results['timestamp']}\n\n"
-    general_report += "**Qualidade da Imagem:** {:.1f}%\n\n".format(results['metrics']['image_quality'])
+        return None, "⚠️ Por favor, carregue uma imagem.", "", "", ""
     
-    # Condições Detalhadas
-    detailed_conditions = "# 🔍 Análise Detalhada por Zona\n\n"
-    recommendations = "# 💡 Recomendações Personalizadas\n\n"
-    health_alerts = "# ⚠️ Alertas e Atenção Especial\n\n"
-    
-    for zone_name, analysis in results["analysis"].items():
-        # Detailed conditions
-        detailed_conditions += f"## {zone_name}\n\n"
-        detailed_conditions += "### Condições Identificadas:\n"
-        for condition in analysis["conditions"]:
-            detailed_conditions += f"- {condition}\n"
-        detailed_conditions += f"\n**Status:** {analysis['status'].title()}\n"
-        detailed_conditions += f"**Confiança da Análise:** {analysis['confianca_analise']}\n"
-        detailed_conditions += "**Métricas Detalhadas:**\n"
-        for metric, value in analysis["metrics"].items():
-            detailed_conditions += f"- {metric.replace('_', ' ').title()}: {value:.1f}\n"
-        detailed_conditions += "\n"
+    try:
+        analyzer = IrisAnalyzer()
+        processed_img, results = analyzer.analyze_iris(img)
+        
+        if "error" in results:
+            return None, f"⚠️ Erro na análise: {results['error']}", "", "", ""
+        
+        # Generate reports
+        general_report = "# 📊 Visão Geral da Análise\n\n"
+        status_counts = {"baixa": 0, "media": 0, "alta": 0}
+        
+        for analysis in results["analysis"].values():
+            status_counts[analysis["status"]] += 1
+        
+        health_score = (
+            (status_counts["alta"] * 100 + status_counts["media"] * 50) /
+            max(1, len(results["analysis"]))
+        )
+        
+        general_report += (
+            f"**Índice de Saúde Geral:** {health_score:.1f}%\n\n"
+            f"**Data da Análise:** {results['timestamp']}\n\n"
+            f"**Qualidade da Imagem:** {results['metrics']['image_quality']:.1f}%\n\n"
+        )
         
-        # Recommendations
-        recommendations += f"## {zone_name}\n\n"
-        for rec in analysis["recommendations"]:
-            recommendations += f"- {rec}\n"
-        recommendations += "\n"
+        # Detailed reports
+        detailed_conditions = "# 🔍 Análise Detalhada por Zona\n\n"
+        recommendations = "# 💡 Recomendações Personalizadas\n\n"
+        health_alerts = "# ⚠️ Alertas e Atenção Especial\n\n"
         
-        # Health alerts
-        if analysis["status"] == "baixa" or analysis["metrics"]["health_score"] < 50:
-            health_alerts += f"## {zone_name}\n"
-            health_alerts += "### Pontos de Atenção:\n"
+        for zone_name, analysis in results["analysis"].items():
+            # Add detailed conditions
+            detailed_conditions += f"## {zone_name}\n\n"
+            detailed_conditions += "### Condições Identificadas:\n"
             for condition in analysis["conditions"]:
-                health_alerts += f"- ⚠️ {condition}\n"
-            health_alerts += "\n### Ações Recomendadas:\n"
+                detailed_conditions += f"- {condition}\n"
+            detailed_conditions += (
+                f"\n**Status:** {analysis['status'].title()}\n"
+                f"**Confiança da Análise:** {analysis['confianca_analise']}\n"
+                "**Métricas Detalhadas:**\n"
+            )
+            for metric, value in analysis["metrics"].items():
+                detailed_conditions += f"- {metric.replace('_', ' ').title()}: {value:.1f}\n"
+            detailed_conditions += "\n"
+            
+            # Add recommendations
+            recommendations += f"## {zone_name}\n\n"
             for rec in analysis["recommendations"]:
-                health_alerts += f"- ✅ {rec}\n"
-            health_alerts += "\n"
-    
-    return [
-        processed_img,
-        general_report,
-        detailed_conditions,
-        recommendations,
-        health_alerts
-    ]
+                recommendations += f"- {rec}\n"
+            recommendations += "\n"
+            
+            # Add health alerts
+            if analysis["status"] == "baixa" or analysis["metrics"]["health_score"] < 50:
+                health_alerts += f"## {zone_name}\n"
+                health_alerts += "### Pontos de Atenção:\n"
+                for condition in analysis["conditions"]:
+                    health_alerts += f"- ⚠️ {condition}\n"
+                health_alerts += "\n### Ações Recomendadas:\n"
+                for rec in analysis["recommendations"]:
+                    health_alerts += f"- ✅ {rec}\n"
+                health_alerts += "\n"
+        
+        return processed_img, general_report, detailed_conditions, recommendations, health_alerts
+        
+    except Exception as e:
+        error_message = f"⚠️ Erro no processamento: {str(e)}"
+        return None, error_message, "", "", ""
 
-# Interface Gradio
+# Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
     # 🔍 Analisador Avançado de Íris
@@ -433,7 +509,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as iface:
     """)
     
     with gr.Tabs() as tabs:
-        with gr.Tab("📸 Análise de Imagem", id=1):
+        with gr.Tab("📸 Análise de Imagem"):
             with gr.Row():
                 with gr.Column(scale=1):
                     input_image = gr.Image(
@@ -447,21 +523,21 @@ with gr.Blocks(theme=gr.themes.Soft()) as iface:
                 with gr.Column(scale=1):
                     output_image = gr.Image(label="Visualização da Análise", height=400)
         
-        with gr.Tab("📊 Resultados", id=2):
+        with gr.Tab("📊 Resultados"):
             with gr.Tabs() as result_tabs:
-                with gr.Tab("📈 Visão Geral", id=2.1):
+                with gr.Tab("📈 Visão Geral"):
                     general_output = gr.Markdown()
                 
-                with gr.Tab("🔍 Condições Detalhadas", id=2.2):
+                with gr.Tab("🔍 Condições Detalhadas"):
                     conditions_output = gr.Markdown()
                 
-                with gr.Tab("💡 Recomendações", id=2.3):
+                with gr.Tab("💡 Recomendações"):
                     recommendations_output = gr.Markdown()
                 
-                with gr.Tab("⚠️ Alertas", id=2.4):
+                with gr.Tab("⚠️ Alertas"):
                     alerts_output = gr.Markdown()
         
-        with gr.Tab("ℹ️ Informações", id=3):
+        with gr.Tab("ℹ️ Informações"):
             gr.Markdown("""
             ## 📚 Sobre a Análise Iridológica
 
@@ -493,7 +569,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as iface:
             - Mantenha check-ups regulares
             """)
     
-    # Configurar eventos
+    # Event handlers
     analyze_btn.click(
         fn=process_image,
         inputs=input_image,