Update app.py

app.py

@@ -194,39 +194,81 @@ class IrisAnalyzer:
         ]
 
     def analyze_iris(self, image: np.ndarray) -> Dict:
+        # Converter para diferentes espaços de cor para análise mais completa
         gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        center = (image.shape[1]//2, image.shape[0]//2)
-        radius = min(image.shape[:2])//4
+        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+        
+        # Detectar centro e borda da íris usando Hough Circles
+        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": {},
-            "recommendations": []
+            "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])
             
+            # Criar máscaras para diferentes análises
             mask = np.zeros(gray.shape, dtype=np.uint8)
             cv2.circle(mask, center, outer_r, 255, -1)
             cv2.circle(mask, center, inner_r, 0, -1)
             
-            zone_intensity = cv2.mean(gray, mask=mask)[0]
+            # Análise multiespectral
+            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)
+            }
             
-            # Análise detalhada baseada na intensidade
-            if zone_intensity < 85:
+            # Análise detalhada baseada em múltiplos fatores
+            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
+            )
+            
+            if health_score < 40:
                 level = "baixa"
-            elif zone_intensity < 170:
+            elif health_score < 75:
                 level = "media"
             else:
                 level = "alta"
                 
             results["analysis"][zone.name] = {
-                "conditions": zone.conditions[level],
-                "recommendations": zone.recommendations[level],
-                "intensity": float(zone_intensity),
-                "status": level
+                "conditions": self._customize_conditions(zone.conditions[level], zone_metrics),
+                "recommendations": self._customize_recommendations(zone.recommendations[level], zone_metrics),
+                "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)
             }
             
             # Marcar zona na imagem
@@ -237,7 +279,52 @@ class IrisAnalyzer:
         
         return image, results
 
-def process_image(img):
+    def _customize_conditions(self, base_conditions: List[str], metrics: Dict) -> List[str]:
+        """Personaliza as condições baseado nas métricas específicas"""
+        customized = []
+        for condition in base_conditions:
+            # Adicionar detalhes específicos baseados nas métricas
+            if metrics["intensity"] < 50:
+                condition += " (intensidade muito baixa)"
+            elif metrics["contrast"] < 30:
+                condition += " (baixo contraste)"
+            
+            if metrics["patterns"] > 70:
+                condition += " (padrões significativos detectados)"
+            
+            customized.append(condition)
+        return customized
+
+    def _customize_recommendations(self, base_recommendations: List[str], metrics: Dict) -> List[str]:
+        """Personaliza as recomendações baseado nas métricas específicas"""
+        customized = []
+        for rec in base_recommendations:
+            # Adicionar detalhes específicos baseados nas métricas
+            if metrics["texture"] < 40:
+                rec += " (prioridade alta)"
+            elif metrics["saturation"] < 50:
+                rec += " (atenção especial necessária)"
+            
+            customized.append(rec)
+        return customized
+
+    def _calculate_confidence(self, metrics: Dict) -> str:
+        """Calcula o nível de confiança da análise baseado nas métricas"""
+        confidence_score = (
+            metrics["intensity"] * 0.25 +
+            metrics["contrast"] * 0.25 +
+            metrics["texture"] * 0.25 +
+            metrics["patterns"] * 0.25
+        )
+        
+        if confidence_score > 75:
+            return "alta"
+        elif confidence_score > 50:
+            return "média"
+        else:
+            return "baixa"
+
+    def process_image(img):
     if img is None:
         return [None] * 5, gr.Warning("Por favor, carregue uma imagem.")