Update app.py

app.py

@@ -1,6 +1,7 @@
 import numpy as np
 import soundfile as sf
 import gradio as gr
+import math
 
 def binauralize(audio_file, simulate_rotation, rotation_speed):
     """
@@ -17,30 +18,25 @@ def binauralize(audio_file, simulate_rotation, rotation_speed):
         status (str): Status message.
     """
     try:
-        # Load input audio file
         audio, sr = sf.read(audio_file)
     except Exception as e:
         return None, f"Error reading input audio file: {e}"
     
-    # If the audio is stereo, convert to mono by averaging channels
+    # Convert to mono if needed.
     if audio.ndim > 1:
         audio = np.mean(audio, axis=1)
     
-    # Create a time vector for the audio length
     t = np.arange(len(audio)) / sr
     
     if simulate_rotation:
         # Compute a time-varying angle for a full cycle (2π) at the desired rotation speed.
         angle = 2 * np.pi * rotation_speed * t
-        # Constant power panning: left uses cosine, right uses sine.
         left = np.cos(angle) * audio
         right = np.sin(angle) * audio
     else:
-        # If rotation is not enabled, duplicate the audio to both channels.
         left = audio
         right = audio
     
-    # Combine the channels into a stereo signal.
     binaural_audio = np.stack((left, right), axis=-1)
     
     # Normalize to prevent clipping.
@@ -48,7 +44,6 @@ def binauralize(audio_file, simulate_rotation, rotation_speed):
     if max_val > 0:
         binaural_audio = binaural_audio / max_val
     
-    # Save the output to a WAV file.
     output_file = "output_binaural.wav"
     try:
         sf.write(output_file, binaural_audio, sr)
@@ -57,16 +52,66 @@ def binauralize(audio_file, simulate_rotation, rotation_speed):
     
     return output_file, "Binaural conversion complete!"
 
+def simulate_map(audio_file, listener_x, listener_y):
+    """
+    Process an input audio file and simulate binaural panning based on the listener's position.
+    The source is fixed at (0,0). Listener coordinates (listener_x, listener_y) determine the angle.
+    Also applies optional distance attenuation.
+    """
+    try:
+        audio, sr = sf.read(audio_file)
+    except Exception as e:
+        return None, f"Error reading input audio file: {e}"
+    
+    if audio.ndim > 1:
+        audio = np.mean(audio, axis=1)
+        
+    # Compute the angle (in radians) between the listener position and the source at (0,0)
+    # Here, we use atan2(listener_x, listener_y) so that a positive X (to the right) yields a positive angle.
+    theta_rad = math.atan2(listener_x, listener_y)
+    theta_deg = theta_rad * 180 / math.pi
+    
+    # Clamp theta to [-90, 90] degrees (for panning purposes)
+    theta_deg = max(-90, min(90, theta_deg))
+    
+    # Map theta from [-90, 90] to a panning parameter p in radians:
+    # When theta_deg = -90, p = 0 (full left); theta_deg = 0, p = 45° in radians; theta_deg = 90, p = 90° (full right)
+    p = (theta_deg + 90) * math.pi / 360
+    
+    left_gain = math.cos(p)
+    right_gain = math.sin(p)
+    
+    # Optional distance attenuation: the further away the listener, the lower the volume.
+    distance = math.sqrt(listener_x**2 + listener_y**2)
+    attenuation = 1 / (1 + distance)
+    
+    left = audio * left_gain * attenuation
+    right = audio * right_gain * attenuation
+    
+    binaural_audio = np.stack((left, right), axis=-1)
+    
+    max_val = np.max(np.abs(binaural_audio))
+    if max_val > 0:
+        binaural_audio = binaural_audio / max_val
+    
+    output_file = "output_map.wav"
+    try:
+        sf.write(output_file, binaural_audio, sr)
+    except Exception as e:
+        return None, f"Error writing output audio file: {e}"
+    
+    return output_file, f"Listener: ({listener_x}, {listener_y}), Angle: {theta_deg:.1f}°"
+
 # Create an enhanced UI using Gradio Blocks and Tabs.
 with gr.Blocks(title="SonicOrbit", css="""
-    /* Custom CSS to enhance spacing and font styling */
     .title { font-size: 2.5em; font-weight: bold; text-align: center; margin-bottom: 0.5em; }
     .subtitle { font-size: 1.2em; text-align: center; margin-bottom: 1em; }
     .footer { text-align: center; font-size: 0.9em; margin-top: 2em; color: #555; }
+    .tab-description { margin: 10px; font-size: 1em; }
     """) as demo:
     
     gr.Markdown("<div class='title'>SonicOrbit</div>")
-    gr.Markdown("<div class='subtitle'>Binaural 360 Audio Converter with Dynamic Rotation</div>")
+    gr.Markdown("<div class='subtitle'>Binaural 360 Audio Converter & Interactive Map</div>")
     
     with gr.Tabs():
         with gr.Tab("Converter"):
@@ -86,32 +131,29 @@ with gr.Blocks(title="SonicOrbit", css="""
                 outputs=[output_audio, status_text]
             )
             
-        with gr.Tab("Instructions"):
-            gr.Markdown("""
-            ### How to Use SonicOrbit
-            1. **Upload Audio:**  
-               Upload a mono or stereo audio file. If you upload a stereo file, it will be converted to mono by averaging the channels.
-            2. **Simulate Rotation:**  
-               Enable this option to apply a dynamic panning effect that simulates a rotating sound source.
-            3. **Rotation Speed:**  
-               Adjust the slider to set the speed of the rotation effect (in Hertz). A higher value rotates the audio field faster.
-            4. **Convert Audio:**  
-               Click the **Convert Audio** button to process your audio file. The output is a binaural (stereo) audio file with the simulated 360° effect.
-               
-            Enjoy your immersive 3D audio experience!
-            """)
-    
+        with gr.Tab("Interactive Map"):
+            gr.Markdown("<div class='tab-description'>Move the listener around the source (fixed at (0,0)) using the sliders. The binaural panning will update based on the listener's position and distance.</div>")
+            with gr.Row():
+                map_audio = gr.Audio(type="filepath", label="Upload Audio (Mono or Stereo)")
+            with gr.Row():
+                listener_x = gr.Slider(-10, 10, value=0, step=0.1, label="Listener X Position")
+                listener_y = gr.Slider(-10, 10, value=1, step=0.1, label="Listener Y Position")
+            map_button = gr.Button("Update Listener Position")
+            with gr.Row():
+                map_output = gr.Audio(type="filepath", label="Binaural Map Output")
+                map_status = gr.Textbox(label="Status", interactive=False)
+            
+            map_button.click(
+                fn=simulate_map,
+                inputs=[map_audio, listener_x, listener_y],
+                outputs=[map_output, map_status]
+            )
+            
     gr.Markdown("""
     <div class='footer'>
-      © 2025 SonicOrbit. All rights reserved.
-      <br>
+      © 2025 SonicOrbit. All rights reserved.<br>
       Created with ❤️ by <a href="https://bilsimaging.com" target="_blank" style="color: #88aaff;">bilsimaging.com</a>
-    </div>
-    """)
-
-    gr.HTML("""
-    <div style="text-align: center; margin-top: 1rem;">
-       <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2FSonicOrbit" target="_blank">
+      and this <a href="https://visitorbadge.io/status?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2FSonicOrbit" target="_blank">
       <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fhuggingface.co%2Fspaces%2FBils%2FSonicOrbit&countColor=%23263759" alt="visitor badge" /></a>
     </div>
     """)