**Add GPT‑4 Vision support with detailed prompt and fallback**

Implement GPT‑4 Vision (or Qwen2‑VL) image analysis for turbine blade inspection, using a Spanish prompt that compares YOLO detections and evaluates visual defects. Add a fallback technical analysis when vision models are unavailable. Include a new `setup_qwen_vision.md` file for Qwen configuration.

app.py

@@ -242,7 +242,7 @@ def _extract_path(d):
 
 def analyze_image_with_gpt(image_path, detections_summary=""):
     """
-    Analiza una imagen directamente con GPT para obtener observaciones adicionales
+    Analiza una imagen directamente con GPT-4 Vision para obtener observaciones visuales
     que el modelo YOLO podría haber perdido.
     """
     try:
@@ -250,84 +250,156 @@ def analyze_image_with_gpt(image_path, detections_summary=""):
         if not GPTClass:
             return "Análisis de IA no disponible (GPT wrapper no configurado)"
 
+        # Construir prompt en español para análisis visual directo con GPT-4 Vision
+        prompt = f"""Eres un experto en inspección de palas de aerogeneradores. Analiza visualmente esta imagen de una pala de aerogenerador y proporciona un análisis detallado en español.
+
+DETECCIONES AUTOMÁTICAS DEL MODELO YOLO:
+{detections_summary if detections_summary else "No se detectaron defectos automáticamente"}
+
+INSTRUCCIONES PARA TU ANÁLISIS VISUAL:
+Observa cuidadosamente la imagen y describe:
+
+1. **Condición general de la superficie**: Color, textura, acabado, limpieza
+2. **Borde de ataque (leading edge)**: Estado, erosión, daños, desgaste
+3. **Borde de salida (trailing edge)**: Integridad, grietas, deformaciones
+4. **Superficie principal**: Grietas, decoloración, impactos, reparaciones previas
+5. **Elementos estructurales**: Uniones, tornillos, conexiones visibles
+6. **Contaminación**: Suciedad, hielo, vegetación, residuos
+7. **Daños específicos**: Impactos de rayos, aves, granizo, desgaste UV
+
+COMPARACIÓN CON DETECCIONES AUTOMÁTICAS:
+- Confirma o refuta las detecciones del modelo YOLO
+- Identifica defectos que YOLO pudo haber perdido
+- Evalúa la severidad de los defectos detectados
+
+CONTEXTO DE DEFECTOS COMUNES:
+- **Dirt/Suciedad**: Acumulación que reduce eficiencia aerodinámica
+- **Erosion**: Desgaste del borde de ataque por partículas
+- **Cracks/Grietas**: Fisuras estructurales críticas
+- **Lightning damage**: Daños por descargas eléctricas
+- **Ice**: Formación de hielo estacional
+- **Bird strikes**: Impactos de aves
+- **UV degradation**: Decoloración por radiación solar
+
+IMPORTANTE:
+- Responde SOLO en español
+- Describe específicamente lo que VES en la imagen
+- Sé preciso sobre ubicaciones (izquierda, derecha, centro, bordes)
+- Menciona colores, texturas, patrones específicos
+- Evalúa la severidad de cada problema observado
+
+Formato de respuesta:
+## 🔍 Análisis Visual Directo de la Pala
+
+**Estado General:** [tu evaluación visual del estado]
+
+**Observaciones Específicas:**
+[describe detalladamente lo que ves en cada área]
+
+**Defectos Identificados Visualmente:**
+[lista específica de problemas que observas]
+
+**Comparación con Detección Automática:**
+[confirma/refuta/complementa las detecciones YOLO]
+
+**Severidad y Prioridades:**
+[evalúa qué problemas son más críticos]
+
+**Recomendaciones de Mantenimiento:**
+[acciones específicas basadas en lo observado]
+"""
+
+        # Configurar modelo de visión
+        vision_model_id = os.getenv("VISION_MODEL_ID", "Qwen/Qwen2-VL-7B-Instruct")
+        model_id = os.getenv("MODEL_ID", vision_model_id)
+        wrapper = GPTClass(model=model_id)
+
+        # Intentar usar análisis de imágenes (GPT-4 Vision o Qwen2-VL)
+        try:
+            print(f"DEBUG: Intentando análisis de imagen con modelo: {model_id}")
+            analysis = wrapper.analyze_image(image_path, prompt, max_tokens=1200, temperature=0.2)
+            return analysis
+        except RuntimeError as vision_error:
+            # Si el análisis de visión no está disponible, usar análisis basado en características
+            print(f"DEBUG: Análisis de visión no disponible: {vision_error}")
+            return _fallback_technical_analysis(image_path, detections_summary, wrapper)
+
+    except Exception as e:
+        return f"Error en el análisis de IA: {str(e)}"
+
+def _fallback_technical_analysis(image_path, detections_summary, wrapper):
+    """
+    Análisis de respaldo basado en características técnicas cuando GPT-4 Vision no está disponible.
+    """
+    try:
         # Obtener características visuales básicas de la imagen
         visual_features = compute_visual_features(image_path, [])
 
-        # Construir descripción visual básica
-        visual_desc = ""
+        # Construir descripción técnica detallada
+        technical_desc = "Análisis basado en características técnicas de la imagen:\n"
         if visual_features:
             brightness = visual_features.get("brightness", 0)
             contrast = visual_features.get("contrast", 0)
             blur = visual_features.get("blur", 0)
             dominant_rgb = visual_features.get("dominant_rgb", [])
-
-            bright_desc = "brillante" if brightness > 130 else ("tenue" if brightness < 80 else "moderadamente iluminada")
-            contrast_desc = "alto contraste" if contrast > 60 else ("bajo contraste" if contrast < 30 else "contraste moderado")
-            blur_desc = "borrosa" if blur < 100 else "nítida"
-
-            visual_desc = f"La imagen aparece {bright_desc}, con {contrast_desc}, y está {blur_desc}."
+            width = visual_features.get("width", 0)
+            height = visual_features.get("height", 0)
+
+            technical_desc += f"- Resolución: {width}x{height} píxeles\n"
+            technical_desc += f"- Brillo promedio: {brightness:.1f}/255 "
+            technical_desc += ("(imagen brillante)" if brightness > 130 else "(imagen tenue)" if brightness < 80 else "(iluminación normal)")
+            technical_desc += f"\n- Contraste: {contrast:.1f} "
+            technical_desc += ("(alto contraste)" if contrast > 60 else "(bajo contraste)" if contrast < 30 else "(contraste normal)")
+            technical_desc += f"\n- Nitidez: {blur:.1f} "
+            technical_desc += ("(imagen nítida)" if blur > 100 else "(imagen borrosa)")
             if dominant_rgb:
-                visual_desc += f" Color dominante aproximado: RGB{dominant_rgb}."
-
-        # Construir prompt en español para análisis visual directo
-        prompt = f"""Eres un experto en inspección de palas de aerogeneradores. Analiza esta imagen de una pala de aerogenerador y proporciona un análisis detallado en español.
-
-INFORMACIÓN TÉCNICA DE LA IMAGEN:
-{visual_desc}
+                technical_desc += f"\n- Color dominante: RGB{dominant_rgb}"
+
+                # Interpretar colores dominantes
+                r, g, b = dominant_rgb
+                if r > 150 and g > 150 and b > 150:
+                    technical_desc += " (tonos claros/blancos - superficie limpia)"
+                elif r < 100 and g < 100 and b < 100:
+                    technical_desc += " (tonos oscuros - posible suciedad o sombras)"
+                elif r > g and r > b:
+                    technical_desc += " (tonos rojizos - posible oxidación)"
+                elif g > r and g > b:
+                    technical_desc += " (tonos verdosos - posible vegetación/algas)"
+                elif b > r and b > g:
+                    technical_desc += " (tonos azulados - superficie normal)"
+
+        # Prompt modificado para análisis técnico
+        fallback_prompt = f"""Eres un experto en inspección de palas de aerogeneradores. Basándote en los datos técnicos de la imagen y las detecciones automáticas, proporciona un análisis detallado en español.
+
+{technical_desc}
 
 DETECCIONES AUTOMÁTICAS DEL MODELO YOLO:
 {detections_summary if detections_summary else "No se detectaron defectos automáticamente"}
 
-INSTRUCCIONES PARA TU ANÁLISIS:
-1. Describe lo que observas en la superficie de la pala (color, textura, condiciones generales)
-2. Identifica cualquier anomalía, defecto o área de preocupación que puedas ver visualmente
-3. Menciona específicamente si observas algo que el modelo automático YOLO podría haber perdido
-4. Evalúa el estado general de la pala (excelente, bueno, regular, malo, crítico)
-5. Proporciona recomendaciones específicas de mantenimiento
-
-ÁREAS ESPECÍFICAS A REVISAR:
-- Borde de ataque (leading edge)
-- Borde de salida (trailing edge)
-- Superficie de la pala
-- Uniones y conexiones
-- Grietas, erosión, decoloración
-- Daños por rayos, impactos de aves
-- Acumulación de suciedad o hielo
+NOTA: Este análisis se basa en características técnicas extraídas de la imagen ya que el análisis visual directo no está disponible.
 
-IMPORTANTE:
-- Responde SOLO en español
-- Sé específico sobre ubicaciones y tipos de defectos
-- Si no ves defectos obvios, menciona las características positivas
-- Compara tus observaciones con las detecciones automáticas
+Proporciona un análisis experto interpretando estos datos técnicos en el contexto de inspección de palas de aerogeneradores.
 
 Formato de respuesta:
-## 🔍 Análisis Visual Detallado
-
-**Estado General:** [tu evaluación del estado]
+## 🔍 Análisis Técnico de la Pala
 
-**Observaciones Principales:**
-[describe lo que ves en la superficie, colores, texturas]
+**Estado General:** [evaluación basada en datos técnicos]
 
-**Defectos o Anomalías Detectadas:**
-[cualquier problema que observes, incluso si YOLO no lo detectó]
+**Interpretación de Características:**
+[qué indican los valores técnicos sobre la condición]
 
-**Comparación con Detección Automática:**
-[comenta sobre las detecciones YOLO vs lo que tú observas]
+**Análisis de Detecciones:**
+[interpretación de cada defecto detectado por YOLO]
 
 **Recomendaciones:**
 [acciones específicas recomendadas]
 """
 
-        model_id = os.getenv("MODEL_ID", "gpt-oss-120")
-        wrapper = GPTClass(model=model_id)
-
-        # Generar análisis
-        analysis = wrapper.generate(prompt, max_tokens=1000, temperature=0.2)
-
-        return analysis
+        analysis = wrapper.generate(fallback_prompt, max_tokens=800, temperature=0.3)
+        return f"⚠️ **Análisis técnico** (análisis visual directo no disponible)\n\n{analysis}"
 
     except Exception as e:
-        return f"Error en el análisis de IA: {str(e)}"
+        return f"Error en an��lisis de respaldo: {str(e)}"
 
 
 

gptoss_wrapper.py

@@ -22,6 +22,7 @@ This file intentionally uses only the requests stdlib-friendly HTTP approach to
 import os
 import time
 import requests
+import base64
 from typing import Optional
 
 
@@ -89,6 +90,29 @@ class GPTOSSWrapper:
                 "No API key configured for GPT wrapper. Set OPENAI_API_KEY or HUGGINGFACE_API_TOKEN in the environment."
             )
 
+    def analyze_image(self, image_path: str, prompt: str, max_tokens: int = 512, temperature: float = 0.2) -> str:
+        """
+        Analyze an image using vision models (OpenAI GPT-4 Vision or Hugging Face Qwen2-VL).
+
+        Args:
+            image_path: Path to the image file
+            prompt: Text prompt for analysis
+            max_tokens: Maximum tokens in response
+            temperature: Temperature for generation
+
+        Returns:
+            Analysis text from vision model
+
+        Raises:
+            RuntimeError if no vision model is available or if the call fails
+        """
+        if self.provider == "openai":
+            return self._analyze_image_openai(image_path, prompt, max_tokens, temperature)
+        elif self.provider == "hf":
+            return self._analyze_image_hf(image_path, prompt, max_tokens, temperature)
+        else:
+            raise RuntimeError("Image analysis requires either OpenAI API key or Hugging Face token. Set OPENAI_API_KEY or HUGGINGFACE_API_TOKEN.")
+
     def _generate_openai(self, prompt: str, max_tokens: int, temperature: float) -> str:
         if not self.openai_key:
             raise RuntimeError("OPENAI_API_KEY not set in environment.")
@@ -209,6 +233,188 @@ class GPTOSSWrapper:
         except Exception as e:
             raise RuntimeError(f"Hugging Face API call failed: {e}")
 
+    def _analyze_image_openai(self, image_path: str, prompt: str, max_tokens: int, temperature: float) -> str:
+        """
+        Analyze an image using OpenAI GPT-4 Vision API.
+        """
+        if not self.openai_key:
+            raise RuntimeError("OPENAI_API_KEY not set in environment.")
+
+        # Encode image to base64
+        try:
+            with open(image_path, "rb") as image_file:
+                base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+        except Exception as e:
+            raise RuntimeError(f"Failed to read image file {image_path}: {e}")
+
+        url = "https://api.openai.com/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self.openai_key}",
+            "Content-Type": "application/json",
+        }
+
+        # Use GPT-4 Vision model
+        vision_model = "gpt-4-vision-preview"
+
+        # Build payload for vision API
+        payload = {
+            "model": vision_model,
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are an expert inspection assistant for wind turbine blade images/videos. Analyze images in detail and provide comprehensive assessments in Spanish."
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}",
+                                "detail": "high"
+                            }
+                        }
+                    ]
+                }
+            ],
+            "max_tokens": max_tokens,
+            "temperature": float(temperature),
+        }
+
+        try:
+            r = requests.post(url, headers=headers, json=payload, timeout=60)  # Longer timeout for vision
+            r.raise_for_status()
+            data = r.json()
+
+            choices = data.get("choices", [])
+            if not choices:
+                raise RuntimeError(f"OpenAI Vision returned empty choices: {data}")
+
+            msg = choices[0].get("message", {}).get("content")
+            if msg is None:
+                return str(data)
+            return msg.strip()
+
+        except Exception as e:
+            raise RuntimeError(f"OpenAI Vision API call failed: {e}")
+
+    def _analyze_image_hf(self, image_path: str, prompt: str, max_tokens: int, temperature: float) -> str:
+        """
+        Analyze an image using Hugging Face vision models (like Qwen2-VL).
+        """
+        if not self.hf_token:
+            raise RuntimeError("HUGGINGFACE_API_TOKEN not set in environment.")
+
+        # Encode image to base64
+        try:
+            with open(image_path, "rb") as image_file:
+                base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+        except Exception as e:
+            raise RuntimeError(f"Failed to read image file {image_path}: {e}")
+
+        # Use Qwen2-VL model for vision analysis
+        vision_model = os.getenv("VISION_MODEL_ID", "Qwen/Qwen2-VL-7B-Instruct")
+
+        # Check if we should use the router
+        use_router = False
+        if self.hf_token:
+            hf_use_router_val = os.getenv("HF_USE_ROUTER", "").lower()
+            if hf_use_router_val not in ("0", "false", "no"):
+                use_router = True
+
+        try:
+            if use_router:
+                # Router endpoint for vision models
+                url = "https://router.huggingface.co/v1/chat/completions"
+                headers = {"Authorization": f"Bearer {self.hf_token}", "Content-Type": "application/json"}
+
+                payload = {
+                    "model": vision_model,
+                    "messages": [
+                        {
+                            "role": "system",
+                            "content": "You are an expert inspection assistant for wind turbine blade images/videos. Analyze images in detail and provide comprehensive assessments in Spanish."
+                        },
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": prompt
+                                },
+                                {
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:image/jpeg;base64,{base64_image}"
+                                    }
+                                }
+                            ]
+                        }
+                    ],
+                    "max_tokens": max_tokens,
+                    "temperature": float(temperature),
+                }
+
+                r = requests.post(url, headers=headers, json=payload, timeout=120)
+                r.raise_for_status()
+                data = r.json()
+
+                choices = data.get("choices", [])
+                if choices and isinstance(choices, list):
+                    first = choices[0]
+                    msg = first.get("message", {}).get("content") if isinstance(first, dict) else None
+                    if not msg:
+                        msg = first.get("text") or first.get("content")
+                    if msg:
+                        return msg.strip()
+                return str(data)
+
+            else:
+                # Direct Hugging Face Inference API for vision models
+                url = f"https://api-inference.huggingface.co/models/{vision_model}"
+                headers = {"Authorization": f"Bearer {self.hf_token}"}
+
+                # For vision models, we need to send both text and image
+                payload = {
+                    "inputs": {
+                        "text": prompt,
+                        "image": base64_image
+                    },
+                    "parameters": {
+                        "max_new_tokens": max_tokens,
+                        "temperature": float(temperature),
+                    },
+                    "options": {"wait_for_model": True},
+                }
+
+                r = requests.post(url, headers=headers, json=payload, timeout=120)
+                r.raise_for_status()
+                data = r.json()
+
+                # Handle different response formats
+                if isinstance(data, list) and len(data) > 0:
+                    if isinstance(data[0], dict):
+                        if "generated_text" in data[0]:
+                            return data[0]["generated_text"].strip()
+                        elif "text" in data[0]:
+                            return data[0]["text"].strip()
+                elif isinstance(data, dict):
+                    if "generated_text" in data:
+                        return data["generated_text"].strip()
+                    elif "text" in data:
+                        return data["text"].strip()
+                    elif "error" in data:
+                        raise RuntimeError(f"Hugging Face error: {data['error']}")
+
+                return str(data)
+
+        except Exception as e:
+            raise RuntimeError(f"Hugging Face Vision API call failed: {e}")
+
 
 # Backwards-compatible factory in case caller expects a function or attribute
 def GPTOSSWrapperFactory(model: Optional[str] = None, provider: Optional[str] = None):

setup_qwen_vision.md

@@ -0,0 +1,111 @@
+# Configuración de Qwen2-VL para Análisis de Imágenes
+
+## 🎯 Qwen2-VL: Modelo de Visión Gratuito
+
+Qwen2-VL es un modelo de visión gratuito y potente que puede analizar imágenes directamente. Es una excelente alternativa a GPT-4 Vision.
+
+## 📋 Configuración Rápida
+
+### 1. Obtener Token de Hugging Face (GRATIS)
+
+1. Ve a [huggingface.co](https://huggingface.co)
+2. Crea una cuenta gratuita
+3. Ve a Settings → Access Tokens
+4. Crea un nuevo token con permisos de lectura
+5. Copia el token
+
+### 2. Configurar Variables de Entorno
+
+```bash
+# Windows (PowerShell)
+$env:HUGGINGFACE_API_TOKEN = "hf_tu_token_aqui"
+$env:VISION_MODEL_ID = "Qwen/Qwen2-VL-7B-Instruct"
+$env:HF_USE_ROUTER = "true"
+
+# Linux/Mac
+export HUGGINGFACE_API_TOKEN="hf_tu_token_aqui"
+export VISION_MODEL_ID="Qwen/Qwen2-VL-7B-Instruct"
+export HF_USE_ROUTER="true"
+```
+
+### 3. Modelos Disponibles
+
+**Qwen2-VL (Recomendado):**
+- `Qwen/Qwen2-VL-7B-Instruct` - Modelo principal
+- `Qwen/Qwen2-VL-2B-Instruct` - Versión más ligera
+
+**Otros modelos de visión gratuitos:**
+- `microsoft/kosmos-2-patch14-224`
+- `Salesforce/blip2-opt-2.7b`
+- `llava-hf/llava-1.5-7b-hf`
+
+## 🚀 Uso
+
+Una vez configurado, la aplicación automáticamente:
+
+1. **Detectará** que tienes Hugging Face configurado
+2. **Usará Qwen2-VL** para análisis visual directo
+3. **Proporcionará** análisis detallado en español
+
+## 🔍 Capacidades de Qwen2-VL
+
+- ✅ Análisis visual directo de imágenes
+- ✅ Detección de defectos y anomalías
+- ✅ Descripción detallada de superficies
+- ✅ Comparación con detecciones YOLO
+- ✅ Recomendaciones de mantenimiento
+- ✅ Respuestas en español
+
+## 🛠️ Solución de Problemas
+
+### Error: "Model loading"
+```bash
+# Espera unos minutos, el modelo se está cargando por primera vez
+# Los modelos de HF pueden tardar en "despertar"
+```
+
+### Error: "Token inválido"
+```bash
+# Verifica que el token sea correcto
+echo $HUGGINGFACE_API_TOKEN
+```
+
+### Usar modelo alternativo
+```bash
+# Si Qwen2-VL no funciona, prueba:
+$env:VISION_MODEL_ID = "llava-hf/llava-1.5-7b-hf"
+```
+
+## 📊 Comparación
+
+| Modelo | Costo | Calidad | Velocidad | Configuración |
+|--------|-------|---------|-----------|---------------|
+| GPT-4 Vision | 💰 Pago | 🌟🌟🌟🌟🌟 | 🚀🚀🚀 | Fácil |
+| Qwen2-VL | 🆓 Gratis | 🌟🌟🌟🌟 | 🚀🚀 | Fácil |
+| Análisis técnico | 🆓 Gratis | 🌟🌟 | 🚀🚀🚀 | Automático |
+
+## 🎯 Resultado Esperado
+
+Con Qwen2-VL configurado, obtendrás análisis como:
+
+```markdown
+## 🔍 Análisis Visual Directo de la Pala
+
+**Estado General:** Bueno con mantenimiento menor requerido
+
+**Observaciones Específicas:**
+- Superficie: Color gris uniforme, acabado mate normal
+- Borde de ataque: Erosión leve visible en zona superior
+- Suciedad: Dos áreas de acumulación claramente visibles
+
+**Defectos Identificados Visualmente:**
+- Dirt/suciedad: Confirmado en 2 ubicaciones
+- Erosión menor en borde de ataque
+- Decoloración UV leve
+
+**Recomendaciones:**
+- Limpieza programada (prioridad media)
+- Inspección de erosión (seguimiento)
+```
+
+¡Qwen2-VL te dará análisis visual real y gratuito! 🎉