Update rhythma.py

rhythma.py

@@ -2,28 +2,79 @@ import numpy as np
 import matplotlib.pyplot as plt
 from scipy import signal
 import pandas as pd
+from PIL import Image
+import io
+from sklearn.metrics.pairwise import cosine_similarity
+import soundfile as sf
 
 class RhythmaModulationEngine:
     """
     Rhythma: The Living Modulation Engine
     A dynamic rhythm-based audio modulation system that creates responsive
-    sound experiences based on rhythm patterns.
+    sound experiences based on rhythm patterns and emotional states.
     """
     
-    def __init__(self, base_freq, modulation_type, rhythm_pattern):
+    def __init__(self, base_freq=None, modulation_type="sine", rhythm_pattern=None, emotional_state=None):
         """
         Initialize the RhythmaModulationEngine.
         
         Args:
-            base_freq (float): The base frequency in Hz
+            base_freq (float, optional): The base frequency in Hz
             modulation_type (str): Type of modulation (sine, pulse, chirp)
-            rhythm_pattern (str): Pattern type (calm, active, focused, relaxed)
+            rhythm_pattern (str, optional): Pattern type (calm, active, focused, relaxed)
+            emotional_state (str, optional): Emotional state (anxious, stressed, calm, etc.)
         """
-        self.base_freq = base_freq
         self.modulation_type = modulation_type
-        self.rhythm_pattern = rhythm_pattern
         self.sample_rate = 44100  # Standard audio sample rate
         
+        # Define frequency mappings for emotional states
+        self.emotional_frequencies = {
+            "anxious": 396,
+            "stressed": 528,
+            "calm": 741,
+            "sad": 417,
+            "angry": 852,
+            "fearful": 639,
+            "confused": 285,
+            "happy": 432
+        }
+        
+        # Detailed information about emotional states
+        self.emotional_info = {
+            "anxious": {
+                "name": "Liberating Guilt and Fear",
+                "advice": "The 396 Hz frequency is associated with releasing fear and guilt."
+            },
+            "stressed": {
+                "name": "Transformation and Miracles",
+                "advice": "The 528 Hz frequency is known as the 'miracle tone' for transformation and DNA repair."
+            },
+            "calm": {
+                "name": "Awakening Intuition",
+                "advice": "The 741 Hz frequency is associated with awakening intuition and solving problems."
+            },
+            "sad": {
+                "name": "Facilitating Change",
+                "advice": "The 417 Hz frequency is believed to facilitate change and let go of negative energy."
+            },
+            "angry": {
+                "name": "Returning to Spiritual Order",
+                "advice": "The 852 Hz frequency is associated with returning to spiritual order and inner strength."
+            },
+            "fearful": {
+                "name": "Connecting Relationships",
+                "advice": "The 639 Hz frequency is linked to connecting relationships and understanding."
+            },
+            "confused": {
+                "name": "Quantum Cognition",
+                "advice": "The 285 Hz frequency is believed to influence energy fields and aid in healing."
+            },
+            "happy": {
+                "name": "Harmonizing Vibrations",
+                "advice": "The 432 Hz frequency is associated with harmonizing vibrations and promoting wellbeing."
+            }
+        }
+        
         # Configure rhythm patterns
         self.rhythm_configs = {
             "calm": {
@@ -56,19 +107,30 @@ class RhythmaModulationEngine:
             }
         }
         
-        # Get current rhythm config
-        self.config = self.rhythm_configs.get(
-            rhythm_pattern, 
-            self.rhythm_configs["calm"]  # Default to calm if pattern not found
-        )
-        
-        # Symbolic mapping (for future use in SymphAI core)
+        # Symbolic mapping for rhythm patterns
         self.symbolic_mapping = {
             "calm": "Resonating in the Circle Archetype: completion, wholeness, presence",
             "active": "Resonating in the Spiral Archetype: flow, transition, emergence",
             "focused": "Resonating in the Triangle Archetype: clarity, direction, purpose",
             "relaxed": "Resonating in the Wave Archetype: fluidity, acceptance, surrender"
         }
+        
+        # Set the base frequency based on emotional state if provided, otherwise use base_freq
+        if emotional_state and emotional_state in self.emotional_frequencies:
+            self.emotional_state = emotional_state
+            self.base_freq = self.emotional_frequencies[emotional_state]
+        else:
+            self.emotional_state = None
+            self.base_freq = base_freq or 440  # Default to A4 if no frequency or emotion provided
+            
+        # Set rhythm pattern 
+        self.rhythm_pattern = rhythm_pattern or "calm"  # Default to calm if not provided
+        
+        # Get current rhythm config
+        self.config = self.rhythm_configs.get(
+            self.rhythm_pattern, 
+            self.rhythm_configs["calm"]  # Default to calm if pattern not found
+        )
 
     def _generate_base_wave(self, duration):
         """Generate the base carrier wave"""
@@ -155,6 +217,13 @@ class RhythmaModulationEngine:
         normalized = 0.8 * enriched / np.max(np.abs(enriched))
         
         return normalized
+    
+    def save_audio(self, duration, file_path=None):
+        """Generate and save audio to a file"""
+        audio = self.generate_modulated_wave(duration)
+        file_path = file_path or f"rhythma_{self.base_freq}Hz_{self.rhythm_pattern}.wav"
+        sf.write(file_path, audio, self.sample_rate)
+        return file_path
         
     def visualize_waveform(self, duration):
         """
@@ -177,7 +246,10 @@ class RhythmaModulationEngine:
         
         # Plot time domain
         ax1.plot(t[:1000], modulated[:1000])
-        ax1.set_title(f'Rhythma Modulated Waveform: {self.rhythm_pattern} ({self.modulation_type})')
+        title = f'Rhythma Modulated Waveform: {self.rhythm_pattern} ({self.modulation_type})'
+        if self.emotional_state:
+            title += f' - {self.emotional_state.capitalize()} state'
+        ax1.set_title(title)
         ax1.set_xlabel('Time (s)')
         ax1.set_ylabel('Amplitude')
         
@@ -186,16 +258,162 @@ class RhythmaModulationEngine:
         ax2.pcolormesh(t, f[:500], Sxx[:500], shading='gouraud')
         ax2.set_ylabel('Frequency (Hz)')
         ax2.set_xlabel('Time (s)')
-        ax2.set_title('Spectrogram')
+        ax2.set_title(f'Spectrogram - Base Frequency: {self.base_freq} Hz')
         
         plt.tight_layout()
         
         # Add symbolic interpretation
-        symbolic_text = self.symbolic_mapping.get(self.rhythm_pattern, "")
-        fig.text(0.5, 0.01, symbolic_text, ha='center', fontsize=10, style='italic')
+        fig_text = self.get_symbolic_interpretation()
+        if self.emotional_state:
+            emotion_info = self.emotional_info.get(self.emotional_state, {})
+            if emotion_info:
+                fig_text += f"\n{self.base_freq} Hz - {emotion_info.get('name', '')}"
+        
+        fig.text(0.5, 0.01, fig_text, ha='center', fontsize=10, style='italic')
         
         return fig
+    
+    def get_waveform_image(self):
+        """Generate waveform as a PIL Image"""
+        duration = 0.1  # Short duration for visualization
+        t = np.linspace(0, duration, int(self.sample_rate * duration), False)
+        tone = np.sin(2 * np.pi * self.base_freq * t)
+        
+        plt.figure(figsize=(10, 4))
+        plt.plot(t, tone)
+        plt.title(f"Waveform of {self.base_freq} Hz Tone")
+        plt.xlabel("Time (s)")
+        plt.ylabel("Amplitude")
+        plt.ylim(-1.1, 1.1)
+        plt.grid(True)
+        
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()
+        
+        return Image.open(buf)
         
     def get_symbolic_interpretation(self):
         """Return the symbolic interpretation of the current rhythm pattern"""
-        return self.symbolic_mapping.get(self.rhythm_pattern, "Unknown pattern")
+        return self.symbolic_mapping.get(self.rhythm_pattern, "Unknown pattern")
+
+    def get_emotional_advice(self):
+        """Get advice based on emotional state if available"""
+        if not self.emotional_state:
+            return ""
+            
+        emotion_info = self.emotional_info.get(self.emotional_state, {})
+        if not emotion_info:
+            return ""
+            
+        return f"{emotion_info.get('advice', '')}"
+        
+    def get_complete_analysis(self):
+        """Get a complete analysis including emotional and rhythmic information"""
+        analysis = []
+        
+        if self.emotional_state:
+            emotion_info = self.emotional_info.get(self.emotional_state, {})
+            if emotion_info:
+                analysis.append(f"Emotional State: {self.emotional_state.capitalize()}")
+                analysis.append(f"Resonant Frequency: {self.base_freq} Hz - {emotion_info.get('name', '')}")
+                analysis.append(f"Emotional Advice: {emotion_info.get('advice', '')}")
+        else:
+            analysis.append(f"Base Frequency: {self.base_freq} Hz")
+            
+        analysis.append(f"Rhythm Pattern: {self.rhythm_pattern.capitalize()}")
+        analysis.append(f"Symbolic Interpretation: {self.get_symbolic_interpretation()}")
+        analysis.append(f"Modulation Type: {self.modulation_type.capitalize()}")
+        
+        return "\n\n".join(analysis)
+
+
+class RhythmaSymphAICore:
+    """
+    SymphAI Core - The intelligent symbolic engine that interprets rhythm and state
+    """
+    
+    def __init__(self, rhythm_analyzer=None, pattern_matcher=None):
+        """Initialize the SymphAI Core"""
+        # Default emotional states that can be detected
+        self.emotional_states = [
+            "anxious", "stressed", "calm", "sad", 
+            "angry", "fearful", "confused", "happy"
+        ]
+        
+        # Default rhythm patterns
+        self.rhythm_patterns = [
+            "calm", "active", "focused", "relaxed"
+        ]
+        
+        # Create embeddings for rhythm states if using semantic matching
+        try:
+            from sentence_transformers import SentenceTransformer
+            self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+            self.emotional_embeddings = {
+                emotion: self.embedding_model.encode([emotion]) 
+                for emotion in self.emotional_states
+            }
+            self.rhythm_embeddings = {
+                pattern: self.embedding_model.encode([pattern]) 
+                for pattern in self.rhythm_patterns
+            }
+        except ImportError:
+            self.embedding_model = None
+            self.emotional_embeddings = {}
+            self.rhythm_embeddings = {}
+            print("SentenceTransformer not installed. Semantic matching disabled.")
+    
+    def get_closest_emotional_state(self, input_text):
+        """Map input text to the closest emotional state"""
+        if not self.embedding_model:
+            # Fallback to simple word matching if no embedding model
+            for emotion in self.emotional_states:
+                if emotion in input_text.lower():
+                    return emotion
+            return "calm"  # Default
+            
+        # Use semantic similarity to find the closest emotion
+        input_embedding = self.embedding_model.encode([input_text])
+        similarities = {
+            emotion: cosine_similarity(input_embedding, embedding)[0][0] 
+            for emotion, embedding in self.emotional_embeddings.items()
+        }
+        return max(similarities, key=similarities.get)
+        
+    def get_closest_rhythm_pattern(self, input_text):
+        """Map input text to the closest rhythm pattern"""
+        if not self.embedding_model:
+            # Fallback to simple mapping based on emotional state
+            emotional_state = self.get_closest_emotional_state(input_text)
+            # Map emotional states to rhythm patterns
+            mapping = {
+                "anxious": "active",
+                "stressed": "active",
+                "calm": "calm",
+                "sad": "relaxed",
+                "angry": "active",
+                "fearful": "active",
+                "confused": "focused",
+                "happy": "calm"
+            }
+            return mapping.get(emotional_state, "calm")
+            
+        # Use semantic similarity to find the closest rhythm pattern
+        input_embedding = self.embedding_model.encode([input_text])
+        similarities = {
+            pattern: cosine_similarity(input_embedding, embedding)[0][0] 
+            for pattern, embedding in self.rhythm_embeddings.items()
+        }
+        return max(similarities, key=similarities.get)
+        
+    def analyze_input(self, input_text):
+        """Analyze input text and return appropriate emotional state and rhythm pattern"""
+        emotional_state = self.get_closest_emotional_state(input_text)
+        rhythm_pattern = self.get_closest_rhythm_pattern(input_text)
+        
+        return {
+            "emotional_state": emotional_state,
+            "rhythm_pattern": rhythm_pattern
+        }