Fixed chart rendering

app.py

@@ -65,36 +65,64 @@ print("Model files ready.")
 # Global model cache
 models = {}
 
-def create_emotion_text(valence, arousal):
-    """Create a text-based representation of the emotion coordinates"""
-    # Helper function to get emotion description
-    def get_emotion_description(v, a):
-        if v > 0.5:
-            if a > 0.5: return "Joyful/Excited"
-            elif a < -0.5: return "Content/Peaceful"
-            else: return "Happy/Pleasant"
-        elif v < -0.5:
-            if a > 0.5: return "Angry/Tense"
-            elif a < -0.5: return "Sad/Depressed"
-            else: return "Unhappy/Unpleasant"
-        else:
-            if a > 0.5: return "Alert/Energetic"
-            elif a < -0.5: return "Tired/Calm"
-            else: return "Neutral"
+def create_emotion_plot(valence, arousal):
+    """Create a valence-arousal plot with the predicted emotion point"""
+    # Create figure in a process-safe way
+    fig = plt.figure(figsize=(8, 8), dpi=100)
+    ax = fig.add_subplot(111)
     
-    emotion = get_emotion_description(valence, arousal)
+    # Set background color and style
+    plt.style.use('default')  # Use default style instead of seaborn
+    fig.patch.set_facecolor('#ffffff')
+    ax.set_facecolor('#ffffff')
     
-    return f"""
-    ### Predicted Emotions
+    # Create the coordinate system with a light grid
+    ax.grid(True, linestyle='--', alpha=0.2)
+    ax.axhline(y=0, color='#666666', linestyle='-', alpha=0.3, linewidth=1)
+    ax.axvline(x=0, color='#666666', linestyle='-', alpha=0.3, linewidth=1)
     
-    **Emotion Category:** {emotion}
+    # Plot region
+    circle = plt.Circle((0, 0), 1, fill=False, color='#666666', alpha=0.3, linewidth=1.5)
+    ax.add_artist(circle)
     
-    **Coordinates:**
-    - **Valence:** {valence:.2f} (negative → positive)
-    - **Arousal:** {arousal:.2f} (calm → excited)
+    # Add labels with nice fonts
+    font = {'family': 'sans-serif', 'weight': 'medium', 'size': 12}
+    label_dist = 1.35  # Increased distance for labels
+    ax.text(label_dist, 0, 'Positive', ha='left', va='center', **font)
+    ax.text(-label_dist, 0, 'Negative', ha='right', va='center', **font)
+    ax.text(0, label_dist, 'Excited', ha='center', va='bottom', **font)
+    ax.text(0, -label_dist, 'Calm', ha='center', va='top', **font)
     
-    These values are used to generate music that matches the emotional tone of your image.
-    """
+    # Plot the point with a nice style
+    ax.scatter([valence], [arousal], c='#4f46e5', s=150, zorder=5, alpha=0.8)
+    
+    # Set limits and labels with more padding
+    ax.set_xlim(-1.6, 1.6)
+    ax.set_ylim(-1.6, 1.6)
+    
+    # Format ticks
+    ax.set_xticks([-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5])
+    ax.set_yticks([-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5])
+    ax.tick_params(axis='both', which='major', labelsize=10)
+    
+    # Add axis labels with padding
+    ax.set_xlabel('Valence', **font, labelpad=15)
+    ax.set_ylabel('Arousal', **font, labelpad=15)
+    
+    # Remove spines
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+    
+    # Adjust layout with more padding
+    plt.tight_layout(pad=1.5)
+    
+    # Save to a temporary file and return the path
+    temp_path = os.path.join(os.path.dirname(__file__), "output", "emotion_plot.png")
+    os.makedirs(os.path.dirname(temp_path), exist_ok=True)
+    plt.savefig(temp_path, bbox_inches='tight', dpi=100)
+    plt.close(fig)  # Close the figure to free memory
+    
+    return temp_path
 
 def get_model(conditioning_type):
     """Get or initialize model with specified conditioning"""
@@ -149,22 +177,23 @@ def convert_midi_to_wav(midi_path):
         print(f"Error converting MIDI to WAV: {str(e)}")
         return None
 
-@spaces.GPU(duration=120)  # Set duration to 120 seconds for music generation
+@spaces.GPU(duration=120)
 def generate_music(image, conditioning_type, gen_len, temperature, top_p, min_instruments):
     """Generate music from input image"""
     model = get_model(conditioning_type)
     if model is None:
-        return {
-            emotion_display: None,
-            midi_output: None,
-            results: f"⚠️ Error: Failed to initialize {conditioning_type} model. Please check the logs."
-        }
+        # IMPORTANT: Return a 3-element tuple, not a dictionary
+        return (
+            None,  # For emotion_chart
+            None,  # For midi_output
+            f"⚠️ Error: Failed to initialize {conditioning_type} model. Please check the logs."
+        )
     
     try:
-        # Create output directory with absolute path
+        # Create output directory
         output_dir = os.path.join(os.path.dirname(__file__), "output")
         os.makedirs(output_dir, exist_ok=True)
-        
+
         # Generate music
         valence, arousal, midi_path = model.generate(
             image_path=image,
@@ -176,42 +205,54 @@ def generate_music(image, conditioning_type, gen_len, temperature, top_p, min_in
             min_instruments=int(min_instruments)
         )
         
-        # Ensure we have the absolute path to the MIDI file
-        if not os.path.isabs(midi_path):
-            midi_path = os.path.join(output_dir, midi_path)
-        
-        # Convert MIDI to WAV for playback
+        # Convert MIDI to WAV
         wav_path = convert_midi_to_wav(midi_path)
         if wav_path is None:
-            return {
-                emotion_display: None,
-                midi_output: None,
-                results: "⚠️ Error: Failed to convert MIDI to WAV for playback"
-            }
+            return (
+                None,
+                None,
+                "⚠️ Error: Failed to convert MIDI to WAV for playback"
+            )
         
-        # Create emotion text display
-        emotion_text = create_emotion_text(valence, arousal)
+        # Create emotion plot
+        plot_path = create_emotion_plot(valence, arousal)
         
-        return {
-            emotion_display: emotion_text,
-            midi_output: wav_path,
-            results: f"""
-            **Model Type:** {conditioning_type}
-            
-            **Generation Parameters:**
-            - Temperature: {temperature}
-            - Top-p: {top_p}
-            - Min Instruments: {min_instruments}
-            
-            Your music has been generated! Click the play button above to listen.
-            """
-        }
+        # Build a nice Markdown result string
+        result_text = f"""
+**Model Type:** {conditioning_type}
+
+**Predicted Emotions:**
+- Valence: {valence:.3f} (negative → positive)
+- Arousal: {arousal:.3f} (calm → excited)
+
+**Generation Parameters:**
+- Temperature: {temperature}
+- Top-p: {top_p}
+- Min Instruments: {min_instruments}
+
+Your music has been generated! Click the play button above to listen.
+"""
+
+        # RETURN AS A TUPLE
+        return (plot_path, wav_path, result_text)
+    
     except Exception as e:
-        return {
-            emotion_display: None,
-            midi_output: None,
-            results: f"⚠️ Error generating music: {str(e)}"
-        }
+        return (
+            None,
+            None,
+            f"⚠️ Error generating music: {str(e)}"
+        )
+
+def generate_music_wrapper(image, conditioning_type, gen_len, note_temp, rest_temp, top_p, min_instruments):
+    """Wrapper for generate_music that handles separate temperatures"""
+    return generate_music(
+        image=image,
+        conditioning_type=conditioning_type,
+        gen_len=gen_len,
+        temperature=[float(note_temp), float(rest_temp)],
+        top_p=top_p,
+        min_instruments=min_instruments
+    )
 
 # Create Gradio interface
 with gr.Blocks(title="ARIA - Art to Music Generator", theme=gr.themes.Soft(
@@ -312,11 +353,14 @@ with gr.Blocks(title="ARIA - Art to Music Generator", theme=gr.themes.Soft(
             )
         
         with gr.Column(scale=2):
+            emotion_chart = gr.Image(
+                label="Predicted Emotions",
+                type="filepath"
+            )
             midi_output = gr.Audio(
                 type="filepath",
                 label="Generated Music"
             )
-            emotion_display = gr.Markdown()
             results = gr.Markdown()
     
     gr.Markdown("""
@@ -350,7 +394,7 @@ with gr.Blocks(title="ARIA - Art to Music Generator", theme=gr.themes.Soft(
     generate_btn.click(
         fn=generate_music_wrapper,
         inputs=[image_input, conditioning_type, gen_len, note_temperature, rest_temperature, top_p, min_instruments],
-        outputs=[emotion_display, midi_output, results]
+        outputs=[emotion_chart, midi_output, results]
     )
 
 # Launch app