Update app.py

app.py

@@ -3,6 +3,7 @@ import numpy as np
 import librosa
 from scipy.signal import find_peaks
 from sklearn.cluster import KMeans
+import itertools
 
 class DigitalToneDecoder:
     def __init__(self, frame_ms=40, min_freq=300, max_freq=4000, peak_threshold=0.2, symbols=16):
@@ -21,129 +22,183 @@ class DigitalToneDecoder:
         return y, sr
 
     def calcular_stft(self):
-        # Usar n_fft fijo para evitar mismatch de dimensiones
-        n_fft = 2048
+        n_fft = int(self.sr * 0.05)
+        n_fft = 2 ** int(np.ceil(np.log2(n_fft)))
         hop_length = int(self.sr * self.frame_ms / 1000)
-        
         stft = np.abs(librosa.stft(self.y, n_fft=n_fft, hop_length=hop_length, window="hann"))
         freqs = librosa.fft_frequencies(sr=self.sr, n_fft=n_fft)
         return stft, freqs
 
     def detectar_tonos(self, stft, freqs):
         tonos = []
-        max_freq_idx = len(freqs) - 1
-        
+        max_idx = len(freqs) - 1
+        media_global = np.mean(stft)
+
         for frame in stft.T:
-            if np.max(frame) == 0:
+            energia = np.mean(frame)
+            if energia < media_global * 0.5:
                 continue
-            
-            # Normalizar frame
+
             frame_norm = frame / np.max(frame)
-            
-            # Detectar picos con límites seguros
             peaks, _ = find_peaks(frame_norm, height=self.peak_threshold)
-            
+
             if len(peaks) == 0:
                 continue
-            
-            # FILTRO CRÍTICO: asegurar que los índices caben en freqs
-            peaks_valid = peaks[peaks <= max_freq_idx]
-            
-            if len(peaks_valid) == 0:
+
+            peaks = peaks[peaks <= max_idx]
+
+            if len(peaks) == 0:
                 continue
-            
-            peak_freqs = freqs[peaks_valid]
-            
-            # Filtrar por rango de frecuencia útil
-            peak_freqs = peak_freqs[
-                (peak_freqs >= self.min_freq) & 
-                (peak_freqs <= self.max_freq)
-            ]
-            
-            if len(peak_freqs) > 0:
-                # Tomar la frecuencia más prominente
-                tonos.append(peak_freqs[0])
-        
-        return np.array(tonos) if len(tonos) > 0 else np.array([])
+
+            peak = peaks[np.argmax(frame_norm[peaks])]
+            freq = freqs[peak]
+
+            if self.min_freq <= freq <= self.max_freq:
+                tonos.append(freq)
+
+        tonos = np.array(tonos)
+
+        if len(tonos) > 5:
+            tonos = np.convolve(tonos, np.ones(5)/5, mode="same")
+
+        return tonos
 
     def crear_simbolos(self, tonos):
         if len(tonos) == 0:
             return []
-        
-        # Si hay menos tonos que símbolos, devolver los únicos
+
         if len(tonos) < self.symbols:
             return sorted(np.unique(tonos))
-        
+
         tonos_2d = tonos.reshape(-1, 1)
-        kmeans = KMeans(n_clusters=min(self.symbols, len(tonos_2d)), n_init=10, random_state=42)
+
+        kmeans = KMeans(n_clusters=self.symbols, n_init=10, random_state=42)
         kmeans.fit(tonos_2d)
+
         return sorted(kmeans.cluster_centers_.flatten())
 
     def decodificar(self, tonos, centros):
-        if len(centros) == 0:
-            return ""
-        
-        letras = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
+        letras = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         texto = ""
-        
+
+        if len(centros) == 0:
+            return texto
+
         for f in tonos:
-            # Encontrar centro más cercano con manejo de errores
-            distancias = [abs(f - c) for c in centros]
-            idx = distancias.index(min(distancias))
+            dist = [abs(f - c) for c in centros]
+            idx = dist.index(min(dist))
             texto += letras[idx % len(letras)]
-        
+
         return texto
 
+
+def limpiar_secuencia(texto):
+    resultado = ""
+    prev = None
+
+    for c in texto:
+        if c != prev:
+            resultado += c
+            prev = c
+
+    return resultado
+
+
+diccionario = {
+"amor","sol","luz","voz","mar","ser","ver","sal","mal","bar","real","mesa","casa","cosa",
+"resto","temor","calor","dolor","alma","moral","solar","ramo","roma","rosa","loma","loro",
+"roma","sombra","humo","eco","oro","oro","oro","aire","tierra","fuego","agua"
+}
+
+
+def generar_palabras(letras):
+
+    letras = letras.lower()
+
+    posibles = []
+
+    for l in range(3,7):
+
+        for p in itertools.permutations(letras, l):
+
+            palabra = "".join(p)
+
+            if palabra in diccionario:
+                posibles.append(palabra)
+
+    return list(set(posibles))
+
+
+def generar_frases(palabras):
+
+    frases = []
+
+    for a in palabras:
+        for b in palabras:
+            if a != b:
+                frases.append(a + " " + b)
+
+    return frases[:30]
+
+
 def analizar(audio_path, progress=gr.Progress()):
+
     if audio_path is None:
-        return "⚠️ No hay audio"
-    
-    try:
-        progress(0.2, desc="Cargando audio...")
-        decoder = DigitalToneDecoder()
-        decoder.cargar_audio(audio_path)
-        
-        progress(0.4, desc="Calculando STFT...")
-        stft, freqs = decoder.calcular_stft()
-        
-        progress(0.6, desc="Detectando tonos...")
-        tonos = decoder.detectar_tonos(stft, freqs)
-        
-        if len(tonos) == 0:
-            return "💤 No se detectaron tonos en el rango útil (300-4000Hz)\n\n*Prueba con audio que contenga tonos puros o modulación.*"
-        
-        progress(0.8, desc="Agrupando frecuencias...")
-        centros = decoder.crear_simbolos(tonos)
-        
-        progress(1.0, desc="Decodificando...")
-        texto = decoder.decodificar(tonos, centros)
-        
-        reporte = f"📊 **DATOS TÉCNICOS:**\n"
-        reporte += f"- Tonos detectados: {len(tonos)}\n"
-        reporte += f"- Clusters únicos: {len(centros)}\n"
-        reporte += f"- Frecuencias base: {[f'{c:.1f}Hz' for c in centros]}\n\n"
-        reporte += f"🔤 **SECUENCIA DECODIFICADA:**\n\n`{texto}`\n\n"
-        reporte += f"*Nota: Las letras se asignan por cluster de frecuencia. Interpretación subjetiva.*"
-        
-        return reporte
-        
-    except Exception as e:
-        return f"❌ **ERROR:**\n\n{type(e).__name__}: {str(e)}"
+        return "no audio"
+
+    decoder = DigitalToneDecoder()
+
+    progress(0.2)
+
+    decoder.cargar_audio(audio_path)
+
+    progress(0.4)
+
+    stft, freqs = decoder.calcular_stft()
+
+    progress(0.6)
+
+    tonos = decoder.detectar_tonos(stft, freqs)
+
+    centros = decoder.crear_simbolos(tonos)
+
+    texto = decoder.decodificar(tonos, centros)
+
+    texto_limpio = limpiar_secuencia(texto)
+
+    palabras = generar_palabras(texto_limpio)
+
+    frases = generar_frases(palabras)
+
+    reporte = ""
+
+    reporte += "SECUENCIA\n"
+    reporte += texto + "\n\n"
+
+    reporte += "SECUENCIA LIMPIA\n"
+    reporte += texto_limpio + "\n\n"
+
+    reporte += "PALABRAS POSIBLES\n"
+    reporte += "\n".join(palabras) + "\n\n"
+
+    reporte += "FRASES POSIBLES\n"
+    reporte += "\n".join(frases)
+
+    return reporte
+
 
 with gr.Blocks() as demo:
-    gr.Markdown("""
-    # 📡 Decodificador de Tonos Digitales (DSP Real)
-    ## STFT + Detección de Picos + KMeans Clustering
-    
-    *Basado en modos digitales de radio (PSK31, RTTY).*
-    *Decodifica frecuencias dominantes a símbolos. La interpretación es tuya.*
-    """)
-    
-    audio = gr.Audio(label="Audio", type="filepath", sources=["upload", "microphone"])
-    btn = gr.Button("Decodificar", variant="primary")
-    output = gr.Textbox(label="Resultado", lines=12)
-    
-    btn.click(analizar, inputs=audio, outputs=output)
+
+    gr.Markdown("# Analizador de Ruido a Letras y Palabras")
+
+    audio = gr.Audio(type="filepath", sources=["upload","microphone"])
+
+    boton = gr.Button("Analizar")
+
+    salida = gr.Textbox(lines=20)
+
+    boton.click(analizar, inputs=audio, outputs=salida)
+
 
 if __name__ == "__main__":
     demo.launch()