Update helpers.py

helpers.py

@@ -4,121 +4,92 @@ import numpy as np
 from pydub import AudioSegment
 from pydub.generators import Sine
 from io import BytesIO
+import textwrap
 
-# --- Paleta de Colores Emocionales ---
-EMOTION_COLORS = {
-    "tristeza": [(0, 20, 80), (50, 80, 150), (100, 100, 100)],
-    "miedo": [(10, 0, 10), (50, 20, 50), (120, 100, 120)],
-    "rabia": [(100, 0, 10), (200, 50, 20), (255, 100, 0)],
-    "ansiedad": [(200, 200, 0), (150, 150, 50), (80, 80, 80)],
-    "culpa": [(80, 50, 20), (50, 30, 10), (100, 100, 100)],
-    "soledad": [(20, 20, 40), (80, 80, 120), (150, 150, 180)],
-    "default": [(100, 100, 150), (200, 200, 220), (50, 50, 80)]
-}
-
-def get_color_palette(emotion_text):
-    emotion_text = emotion_text.lower()
-    for key, colors in EMOTION_COLORS.items():
-        if key in emotion_text:
-            return colors
-    return EMOTION_COLORS["default"]
-
-# --- Generación de Audio Elemental ---
-def generate_elemental_audio(element="theta_only", duration_ms=120000):
-    base_freq = 100
-    binaural_freq = 6
-    left_sine = Sine(base_freq).to_audio_segment(duration=duration_ms, volume=-20).set_channels(1)
-    right_sine = Sine(base_freq + binaural_freq).to_audio_segment(duration=duration_ms, volume=-20).set_channels(1)
+def generate_audio(state="intro", duration_ms=120000):
+    if state == "intro":
+        base_freq, binaural_freq, volume = 100, 6, -20 # Theta
+    else: # "outro"
+        base_freq, binaural_freq, volume = 150, 10, -24 # Alpha
+    
+    left_sine = Sine(base_freq).to_audio_segment(duration=duration_ms, volume=volume).set_channels(1)
+    right_sine = Sine(base_freq + binaural_freq).to_audio_segment(duration=duration_ms, volume=volume).set_channels(1)
     binaural_beat = AudioSegment.from_mono_audiosegments(left_sine, right_sine)
-    final_sound = binaural_beat
-    #... (el resto de la lógica de audio se mantiene igual)
-    buffer = BytesIO()
-    final_sound.export(buffer, format="wav")
-    filename = f"{element}_binaural.wav"
-    with open(filename, 'wb') as f:
-        f.write(buffer.getvalue())
+    
+    filename = f"{state}_resonance.wav"
+    binaural_beat.export(filename, format="wav")
     return filename
 
-# --- Generación de Sigilo Bio-Resonante ---
-def generate_bioresonant_sigil(emotion, location, size=512):
-    if not emotion and not location:
-        return Image.new('RGB', (size, size), 'black')
-    text_input = emotion + " " + location
+def generate_bioresonant_sigil(text_input, size=512):
+    if not text_input: return Image.new('RGB', (size, size), 'black')
+    
     hash_object = hashlib.sha256(text_input.encode('utf-8'))
-    hex_dig = hash_object.hexdigest()
-    seed = [int(hex_dig[i:i+2], 16) for i in range(0, len(hex_dig), 2)]
-    img = Image.new('RGB', (size, size), 'black')
+    seed = [int(c, 16) for c in hash_object.hexdigest()]
+    
+    img = Image.new('RGB', (size, size), (10, 5, 15))
     draw = ImageDraw.Draw(img)
     center_x, center_y = size // 2, size // 2
-    palette = get_color_palette(emotion)
-    location = location.lower()
-    num_lines = 8 + (seed[0] % 8)
-    base_radius_factor = 0.2
-    #... (el resto de la lógica del sigilo se mantiene igual)
-    for i in range(num_lines):
-        # ... Lógica de dibujo ...
+    
+    for i in range(16):
         s_idx = (i * 4) % len(seed)
-        color = palette[i % len(palette)]
-        start_angle = (seed[s_idx] / 255) * 360
-        end_angle = (seed[s_idx+1] / 255) * 360
-        radius1 = size * base_radius_factor + (seed[s_idx+2] / 255) * (size * 0.2)
-        radius2 = size * 0.1 + (seed[s_idx+3] / 255) * (size * 0.4)
-        start_x = center_x + radius1 * np.cos(np.deg2rad(start_angle))
-        start_y = center_y + radius1 * np.sin(np.deg2rad(start_angle))
-        end_x = center_x + radius2 * np.cos(np.deg2rad(end_angle))
-        end_y = center_y + radius2 * np.sin(np.deg2rad(end_angle))
-        draw.line((start_x, start_y, end_x, end_y), fill=color, width=1)
-        draw.line((size - start_x, start_y, size - end_x, end_y), fill=color, width=1)
-    return img.filter(ImageFilter.GaussianBlur(radius=1))
+        angle = (sum(seed[s_idx:s_idx+4]) / (15*4)) * 2 * np.pi
+        radius = (seed[(i+1)%len(seed)] / 15) * (size * 0.45)
+        color = (50 + seed[(i+2)%len(seed)]*12, 50 + seed[(i+3)%len(seed)]*8, 100 + seed[i]*10)
+        
+        x1 = center_x + radius * np.cos(angle)
+        y1 = center_y + radius * np.sin(angle)
+        x2 = center_x - radius * np.cos(angle)
+        y2 = center_y - radius * np.sin(angle)
+        draw.line((x1, y1, x2, y2), fill=color, width=2)
 
+    # Efecto de brillo
+    glow = img.filter(ImageFilter.GaussianBlur(radius=size*0.05))
+    return Image.alpha_composite(img.convert('RGBA'), glow.convert('RGBA')).convert('RGB')
 
-# --- NUEVA FUNCIÓN: Generador de GIF Autónomo ---
 def create_quantum_tunnel_gif(filename="quantum_tunnel.gif", size=300, num_frames=20):
-    """
-    Genera un GIF animado de un túnel de partículas abstractas.
-    """
+    # (Esta función se mantiene igual que la v3.0)
     frames = []
     for i in range(num_frames):
-        # Fondo oscuro
-        img = Image.new('RGB', (size, size), (13, 13, 13))
-        draw = ImageDraw.Draw(img)
+        img = Image.new('RGB', (size, size), (13, 13, 13)); draw = ImageDraw.Draw(img)
         center_x, center_y = size // 2, size // 2
-        
-        # Simular partículas moviéndose
-        # La semilla cambia con cada frame para la animación
         np.random.seed(i)
-        
-        for _ in range(100): # 100 partículas por frame
-            # Posición inicial aleatoria
-            angle = np.random.uniform(0, 2 * np.pi)
-            radius = np.random.uniform(0, size / 2)
-            
-            # Mover la partícula hacia afuera
-            radius_offset = (i / num_frames) * 20 # Mueve las partículas
-            new_radius = (radius + radius_offset) % (size / 2)
-            
-            x = center_x + new_radius * np.cos(angle)
-            y = center_y + new_radius * np.sin(angle)
-            
-            # El color se basa en la paleta del Crisol
-            color = (
-                np.random.randint(150, 220), # R
-                np.random.randint(100, 200), # G
-                np.random.randint(200, 255)  # B -> Tonos púrpura/azulados
-            )
-            
-            # Dibujar partícula
+        for _ in range(100):
+            angle = np.random.uniform(0, 2*np.pi); radius = np.random.uniform(0, size/2)
+            new_radius = (radius + (i/num_frames)*20) % (size/2)
+            x = center_x + new_radius*np.cos(angle); y = center_y + new_radius*np.sin(angle)
+            color = (np.random.randint(150,220), np.random.randint(100,200), np.random.randint(200,255))
             draw.point((x, y), fill=color)
-
         frames.append(img)
+    frames[0].save(filename, save_all=True, append_images=frames[1:], optimize=False, duration=100, loop=0)
+    return filename
 
-    # Guardar los frames como un GIF animado
-    frames[0].save(
-        filename,
-        save_all=True,
-        append_images=frames[1:],
-        optimize=False,
-        duration=100, # ms por frame
-        loop=0 # bucle infinito
-    )
+def create_soul_artifact(sigil_img, title, key, filename="Soul_Artifact.png"):
+    width, height = sigil_img.size
+    bg_color = (10, 5, 15)
+    text_color = (230, 220, 255)
+    
+    # Crear un lienzo más grande para añadir texto
+    artifact = Image.new('RGB', (width, height + 200), bg_color)
+    artifact.paste(sigil_img, (0, 0))
+    draw = ImageDraw.Draw(artifact)
+
+    # Usar una fuente predeterminada (Pillow buscará una)
+    try:
+        title_font = ImageFont.truetype("DejaVuSans-Bold.ttf", 32)
+    except IOError:
+        title_font = ImageFont.load_default()
+    try:
+        key_font = ImageFont.truetype("DejaVuSans.ttf", 24)
+    except IOError:
+        key_font = ImageFont.load_default()
+        
+    # Dibujar Título
+    wrapped_title = textwrap.fill(title, width=30)
+    draw.text((width/2, height + 50), wrapped_title, font=title_font, fill=text_color, anchor="ms", align="center")
+    
+    # Dibujar Llave Resonante
+    wrapped_key = textwrap.fill(f'"{key}"', width=40)
+    draw.text((width/2, height + 130), wrapped_key, font=key_font, fill=text_color, anchor="ms", align="center")
+    
+    artifact.save(filename)
     return filename