Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import cv2 | |
| import numpy as np | |
| from dataclasses import dataclass | |
| from typing import Dict, List, Tuple, Optional | |
| from datetime import datetime | |
| class IrisZone: | |
| name: str | |
| ratio: Tuple[float, float] # (inner, outer) | |
| color: Tuple[int, int, int] | |
| conditions: Dict[str, List[str]] | |
| recommendations: Dict[str, List[str]] | |
| class IrisAnalyzer: | |
| def __init__(self): | |
| self.zones = [ | |
| IrisZone( | |
| name="Zona Cerebral/Neural", | |
| ratio=(0.85, 1.0), | |
| color=(255, 0, 0), | |
| conditions={ | |
| "baixa": [ | |
| "Possível fadiga neural crônica", | |
| "Indicadores de estresse prolongado", | |
| "Sinais de insônia ou distúrbios do sono", | |
| "Possível déficit de vitamina B12" | |
| ], | |
| "media": ["Estado neural estável", "Função cognitiva normal"], | |
| "alta": ["Excelente saúde neural", "Ótima resposta cognitiva"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Suplementação de vitamina B12", | |
| "Técnicas de meditação diária", | |
| "Melhorar qualidade do sono", | |
| "Reduzir exposição a telas" | |
| ], | |
| "media": ["Manter rotina de sono", "Exercícios mentais regulares"], | |
| "alta": ["Manter práticas atuais", "Exercícios de mindfulness"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Digestiva", | |
| ratio=(0.7, 0.85), | |
| color=(0, 255, 0), | |
| conditions={ | |
| "baixa": [ | |
| "Possível inflamação intestinal", | |
| "Sinais de má absorção", | |
| "Indicadores de disbiose", | |
| "Possível deficiência enzimática" | |
| ], | |
| "media": ["Digestão funcional", "Absorção adequada"], | |
| "alta": ["Excelente saúde digestiva", "Ótima absorção"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Probióticos específicos", | |
| "Enzimas digestivas", | |
| "Dieta anti-inflamatória", | |
| "Eliminar alimentos processados" | |
| ], | |
| "media": ["Manter dieta balanceada", "Hidratação adequada"], | |
| "alta": ["Manter dieta atual", "Rotina alimentar saudável"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Respiratória", | |
| ratio=(0.55, 0.7), | |
| color=(0, 0, 255), | |
| conditions={ | |
| "baixa": [ | |
| "Possível comprometimento respiratório", | |
| "Sinais de baixa oxigenação", | |
| "Indicadores de congestão brônquica", | |
| "Possível sensibilidade respiratória" | |
| ], | |
| "media": ["Função respiratória adequada", "Oxigenação normal"], | |
| "alta": ["Excelente capacidade respiratória", "Ótima oxigenação"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Exercícios respiratórios diários", | |
| "Avaliar qualidade do ar", | |
| "Considerar atividades aeróbicas", | |
| "Técnicas de respiração profunda" | |
| ], | |
| "media": ["Manter exercícios regulares", "Praticar respiração consciente"], | |
| "alta": ["Continuar práticas saudáveis", "Manter atividades aeróbicas"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Circulatória", | |
| ratio=(0.4, 0.55), | |
| color=(255, 255, 0), | |
| conditions={ | |
| "baixa": [ | |
| "Possível circulação periférica reduzida", | |
| "Indicadores de estagnação sanguínea", | |
| "Sinais de baixo fluxo sanguíneo", | |
| "Possível deficiência de ferro" | |
| ], | |
| "media": ["Circulação adequada", "Fluxo sanguíneo normal"], | |
| "alta": ["Excelente circulação", "Ótimo fluxo sanguíneo"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Aumentar atividade física", | |
| "Considerar suplementação de ferro", | |
| "Massagens circulatórias", | |
| "Hidratação adequada" | |
| ], | |
| "media": ["Manter exercícios regulares", "Alimentação rica em ferro"], | |
| "alta": ["Manter rotina atual", "Continuar exercícios"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Linfática", | |
| ratio=(0.25, 0.4), | |
| color=(255, 0, 255), | |
| conditions={ | |
| "baixa": [ | |
| "Sistema linfático congestionado", | |
| "Possível retenção de líquidos", | |
| "Indicadores de toxicidade", | |
| "Baixa resposta imunológica" | |
| ], | |
| "media": ["Sistema linfático funcional", "Drenagem adequada"], | |
| "alta": ["Excelente drenagem linfática", "Ótima desintoxicação"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Drenagem linfática regular", | |
| "Aumentar consumo de água", | |
| "Exercícios específicos", | |
| "Dieta desintoxicante" | |
| ], | |
| "media": ["Manter hidratação", "Exercícios leves regulares"], | |
| "alta": ["Manter hábitos atuais", "Continuar atividades físicas"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Endócrina", | |
| ratio=(0.15, 0.25), | |
| color=(0, 255, 255), | |
| conditions={ | |
| "baixa": [ | |
| "Possível desequilíbrio hormonal", | |
| "Sinais de estresse adrenal", | |
| "Indicadores de fadiga endócrina", | |
| "Possível disfunção tireoidiana" | |
| ], | |
| "media": ["Sistema endócrino estável", "Função hormonal adequada"], | |
| "alta": ["Excelente equilíbrio hormonal", "Ótima função endócrina"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Gestão do estresse", | |
| "Suporte adrenal natural", | |
| "Regular ciclo sono-vigília", | |
| "Alimentação rica em iodo" | |
| ], | |
| "media": ["Manter rotina regular", "Cuidar do sono"], | |
| "alta": ["Manter equilíbrio atual", "Continuar boas práticas"] | |
| } | |
| ), | |
| IrisZone( | |
| name="Zona Pupilar", | |
| ratio=(0, 0.15), | |
| color=(128, 128, 128), | |
| conditions={ | |
| "baixa": [ | |
| "Sistema nervoso autônomo sobrecarregado", | |
| "Possível desequilíbrio simpático/parassimpático", | |
| "Indicadores de estresse crônico", | |
| "Sinais de fadiga autonômica" | |
| ], | |
| "media": ["SNA equilibrado", "Resposta autonômica normal"], | |
| "alta": ["Excelente regulação autonômica", "Ótimo equilíbrio do SNA"] | |
| }, | |
| recommendations={ | |
| "baixa": [ | |
| "Técnicas de relaxamento", | |
| "Práticas de mindfulness", | |
| "Regular rotina diária", | |
| "Exercícios de respiração" | |
| ], | |
| "media": ["Manter práticas relaxantes", "Continuar boa rotina"], | |
| "alta": ["Manter equilíbrio atual", "Continuar práticas saudáveis"] | |
| } | |
| ) | |
| ] | |
| def _assess_image_quality(self, image: np.ndarray) -> float: | |
| """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: | |
| """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] | |
| 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: | |
| """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) | |
| 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: | |
| """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) | |
| 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: | |
| 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]: | |
| """Customize recommendations based on metrics.""" | |
| customized = [] | |
| for rec in base_recommendations: | |
| 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: | |
| """Calculate analysis confidence level.""" | |
| 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 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) | |
| # 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) | |
| # 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 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: | |
| # 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": { | |
| "iris_radius": radius, | |
| "image_quality": self._assess_image_quality(image) | |
| } | |
| } | |
| # 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: 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, "⚠️ Por favor, carregue uma imagem.", "", "", "" | |
| 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" | |
| ) | |
| # 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" | |
| 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"]: | |
| 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"]: | |
| 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, "", "", "" | |
| # Gradio Interface | |
| with gr.Blocks(theme=gr.themes.Soft()) as iface: | |
| gr.Markdown(""" | |
| # 🔍 Analisador Avançado de Íris | |
| ### Sistema Educacional de Análise Iridológica v2.0 | |
| ⚠️ Este é um sistema para fins educacionais. Não utilize para diagnósticos médicos. | |
| """) | |
| with gr.Tabs() as tabs: | |
| with gr.Tab("📸 Análise de Imagem"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| input_image = gr.Image( | |
| label="Upload da Imagem da Íris", | |
| type="numpy", | |
| sources=["upload", "webcam", "clipboard"], | |
| height=400 | |
| ) | |
| analyze_btn = gr.Button("🔍 Analisar Íris", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| output_image = gr.Image(label="Visualização da Análise", height=400) | |
| with gr.Tab("📊 Resultados"): | |
| with gr.Tabs() as result_tabs: | |
| with gr.Tab("📈 Visão Geral"): | |
| general_output = gr.Markdown() | |
| with gr.Tab("🔍 Condições Detalhadas"): | |
| conditions_output = gr.Markdown() | |
| with gr.Tab("💡 Recomendações"): | |
| recommendations_output = gr.Markdown() | |
| with gr.Tab("⚠️ Alertas"): | |
| alerts_output = gr.Markdown() | |
| with gr.Tab("ℹ️ Informações"): | |
| gr.Markdown(""" | |
| ## 📚 Sobre a Análise Iridológica | |
| ### 🎯 Zonas Analisadas: | |
| 1. **Zona Cerebral/Neural** - Sistema nervoso central e periférico | |
| 2. **Zona Digestiva** - Sistema digestório completo | |
| 3. **Zona Respiratória** - Sistema respiratório | |
| 4. **Zona Circulatória** - Sistema cardiovascular | |
| 5. **Zona Linfática** - Sistema imunológico | |
| 6. **Zona Endócrina** - Sistema hormonal | |
| 7. **Zona Pupilar** - Sistema nervoso autônomo | |
| ### 📋 Como Usar: | |
| 1. Faça upload de uma imagem clara da íris | |
| 2. Clique em "Analisar Íris" | |
| 3. Verifique os resultados nas diferentes abas | |
| 4. Consulte os alertas e recomendações | |
| ### 🔍 Interpretação dos Resultados: | |
| - **Visão Geral**: Índice geral de saúde e qualidade da análise | |
| - **Condições**: Análise detalhada por zona | |
| - **Recomendações**: Sugestões personalizadas | |
| - **Alertas**: Pontos que requerem atenção especial | |
| ### ⚠️ Observações Importantes: | |
| - Sistema para fins educacionais | |
| - Não substitui avaliação médica | |
| - Consulte profissionais de saúde | |
| - Mantenha check-ups regulares | |
| """) | |
| # Event handlers | |
| analyze_btn.click( | |
| fn=process_image, | |
| inputs=input_image, | |
| outputs=[ | |
| output_image, | |
| general_output, | |
| conditions_output, | |
| recommendations_output, | |
| alerts_output | |
| ] | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch() |