Create app.py

app.py

@@ -0,0 +1,188 @@
+import gradio as gr
+import numpy as np
+import pyaudio
+import wave
+from scipy import signal
+import matplotlib.pyplot as plt
+from io import BytesIO
+from PIL import Image
+import time
+import threading
+
+# Bloqueamos la advertencia de matplotlib sobre el backend interactivo
+plt.switch_backend('Agg')
+
+class AguaVozReal:
+    def __init__(self):
+        self.CHUNK = 1024 * 4
+        self.FORMAT = pyaudio.paInt16
+        self.CHANNELS = 1
+        self.RATE = 44100
+        self.buffer_size = self.RATE * 2
+        self.audio_buffer = np.zeros(self.buffer_size)
+        self.buffer_index = 0
+        self.p = pyaudio.PyAudio()
+        self.stream = None
+        self.audio_thread = None
+        self.running = False
+
+    def start_stream(self):
+        """Inicia el stream de audio en un hilo separado"""
+        if self.stream is None:
+            self.stream = self.p.open(
+                format=self.FORMAT,
+                channels=self.CHANNELS,
+                rate=self.RATE,
+                input=True,
+                frames_per_buffer=self.CHUNK,
+                stream_callback=self.audio_callback
+            )
+            self.stream.start_stream()
+            self.running = True
+
+    def audio_callback(self, in_data, frame_count, time_info, status):
+        """Rellena el buffer circular con el audio entrante"""
+        audio_data = np.frombuffer(in_data, dtype=np.int16)
+        for i, sample in enumerate(audio_data):
+            self.audio_buffer[self.buffer_index] = sample
+            self.buffer_index = (self.buffer_index + 1) % self.buffer_size
+        return (in_data, pyaudio.paContinue)
+
+    def get_current_pattern(self):
+        """Genera la imagen del patrón de agua basado en el audio actual"""
+        # Crear la malla de coordenadas
+        x = np.linspace(-2, 2, 200)
+        y = np.linspace(-2, 2, 200)
+        X, Y = np.meshgrid(x, y)
+        r = np.sqrt(X**2 + Y**2)
+        theta = np.arctan2(Y, X)
+
+        # 1. Obtener y analizar el audio del buffer
+        if self.buffer_index >= self.RATE:
+            audio_slice = self.audio_buffer[self.buffer_index-self.RATE:self.buffer_index]
+        else:
+            part1 = self.audio_buffer[self.buffer_index-self.RATE:]
+            part2 = self.audio_buffer[:self.buffer_index]
+            audio_slice = np.concatenate([part1, part2])
+
+        # 2. Calcular espectrograma para obtener energía por frecuencia
+        freqs, times, Sxx = signal.spectrogram(
+            audio_slice,
+            fs=self.RATE,
+            nperseg=512,
+            noverlap=256
+        )
+
+        # 3. Calcular energía en diferentes bandas de frecuencia
+        low_energy = np.sum(Sxx[freqs < 200]) if np.any(freqs < 200) else 0
+        mid_energy = np.sum(Sxx[(freqs >= 200) & (freqs < 1000)]) if np.any((freqs >= 200) & (freqs < 1000)) else 0
+        high_energy = np.sum(Sxx[freqs >= 1000]) if np.any(freqs >= 1000) else 0
+
+        # 4. Determinar el patrón de agua según la energía dominante
+        if low_energy > mid_energy and low_energy > high_energy:
+            # Modo grave: ondas circulares concéntricas
+            Z = 0.5 * np.sin(3 * r - 2 * time.time()) * np.exp(-0.5 * r)
+            titulo = "🌊 Agua: Modo Grave (Ondas Circulares)"
+        elif mid_energy > low_energy and mid_energy > high_energy:
+            # Modo medio: patrón de cuadrícula
+            Z = 0.5 * (np.sin(4 * X - 3 * time.time()) * np.cos(4 * Y - 2 * time.time()))
+            titulo = "🌀 Agua: Modo Medio (Ondas Estacionarias)"
+        else:
+            # Modo agudo: patrones hexagonales/complejos
+            Z = 0.3 * (np.sin(5 * r + 6 * theta) + np.sin(5 * r - 6 * theta)) * np.exp(-0.3 * r)
+            titulo = "❄️ Agua: Modo Agudo (Patrones Hexagonales)"
+
+        # Normalizar la altura para la visualización
+        Z = (Z - Z.min()) / (Z.max() - Z.min() + 1e-10)
+        Z = Z * 2 - 1
+
+        # 5. Generar la imagen con matplotlib
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+        # Subplot 3D
+        ax3d = fig.add_subplot(121, projection='3d')
+        surf = ax3d.plot_surface(X, Y, Z, cmap='ocean', linewidth=0, antialiased=True, alpha=0.8)
+        ax3d.set_zlim(-1.5, 1.5)
+        ax3d.set_title("🌊 Superficie 3D")
+        ax3d.axis('off')
+
+        # Subplot 2D (Contorno)
+        contour = ax2.contourf(X, Y, Z, levels=20, cmap='Blues')
+        ax2.contour(X, Y, Z, levels=10, colors='darkblue', linewidths=0.5)
+        ax2.set_title("🗺️ Patrón de Ondas")
+        ax2.set_aspect('equal')
+        ax2.axis('off')
+
+        plt.suptitle(titulo, fontsize=16)
+        plt.tight_layout()
+
+        # Convertir el plot a imagen PNG para devolverla por Gradio
+        buf = BytesIO()
+        plt.savefig(buf, format='png', dpi=100)
+        buf.seek(0)
+        img = Image.open(buf)
+        plt.close(fig)  # Importante cerrar la figura para liberar memoria
+        return img
+
+# --- Instancia global de la clase y preparación del audio ---
+agua_app = AguaVozReal()
+# Iniciamos el stream de audio tan pronto se carga la app
+try:
+    agua_app.start_stream()
+    print("Stream de audio iniciado.")
+except Exception as e:
+    print(f"Error al iniciar stream: {e}. ¿Micrófono conectado?")
+
+# --- Función principal para Gradio ---
+def generar_patron():
+    """Función que llama Gradio para obtener la imagen actualizada."""
+    if agua_app.running:
+        try:
+            img = agua_app.get_current_pattern()
+            return img
+        except Exception as e:
+            # Crear imagen de error
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, f'Error: {str(e)}', ha='center', va='center')
+            ax.axis('off')
+            buf = BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
+            img = Image.open(buf)
+            plt.close(fig)
+            return img
+    else:
+        # Crear imagen de "sin audio"
+        fig, ax = plt.subplots()
+        ax.text(0.5, 0.5, 'Micrófono no disponible', ha='center', va='center')
+        ax.axis('off')
+        buf = BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        img = Image.open(buf)
+        plt.close(fig)
+        return img
+
+# --- Interfaz Gradio ---
+with gr.Blocks(title="Simulador de Agua por Voz", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎤🌊 Simulador de Agua por Voz")
+    gr.Markdown("Habla al micrófono. El agua generará ondas según la *energía* de tu voz (Grave ↔ Agudo).")
+
+    with gr.Row():
+        with gr.Column():
+            audio_input = gr.Audio(source="microphone", type="numpy", label="Habla aquí")
+            btn_actualizar = gr.Button("Refrescar Patrón")
+
+        with gr.Column():
+            imagen_output = gr.Image(label="Reacción del Agua", value=generar_patron)
+
+    # Actualizar automáticamente cuando se detecta audio
+    audio_input.change(fn=generar_patron, outputs=imagen_input)
+    btn_actualizar.click(fn=generar_patron, outputs=imagen_output)
+
+    # Actualización periódica cada 2 segundos para movimiento continuo
+    demo.load(generar_patron, every=2, outputs=imagen_output)
+
+# Para ejecutar localmente, pero HF usará la interfaz 'demo'
+if __name__ == "__main__":
+    demo.launch()