Create rhythma.py

rhythma.py

@@ -0,0 +1,201 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import signal
+import pandas as pd
+
+class RhythmaModulationEngine:
+    """
+    Rhythma: The Living Modulation Engine
+    A dynamic rhythm-based audio modulation system that creates responsive
+    sound experiences based on rhythm patterns.
+    """
+    
+    def __init__(self, base_freq, modulation_type, rhythm_pattern):
+        """
+        Initialize the RhythmaModulationEngine.
+        
+        Args:
+            base_freq (float): The base frequency in Hz
+            modulation_type (str): Type of modulation (sine, pulse, chirp)
+            rhythm_pattern (str): Pattern type (calm, active, focused, relaxed)
+        """
+        self.base_freq = base_freq
+        self.modulation_type = modulation_type
+        self.rhythm_pattern = rhythm_pattern
+        self.sample_rate = 44100  # Standard audio sample rate
+        
+        # Configure rhythm patterns
+        self.rhythm_configs = {
+            "calm": {
+                "mod_depth": 0.15,
+                "mod_freq": 0.5,
+                "pulse_width": 0.7,
+                "phase_shift": 0.1,
+                "harmonics": [1.0, 0.5, 0.25, 0.125]
+            },
+            "active": {
+                "mod_depth": 0.4,
+                "mod_freq": 2.5,
+                "pulse_width": 0.3,
+                "phase_shift": 0.3,
+                "harmonics": [1.0, 0.7, 0.5, 0.3]
+            },
+            "focused": {
+                "mod_depth": 0.25,
+                "mod_freq": 1.5,
+                "pulse_width": 0.5,
+                "phase_shift": 0.2,
+                "harmonics": [1.0, 0.6, 0.3, 0.15]
+            },
+            "relaxed": {
+                "mod_depth": 0.2,
+                "mod_freq": 0.3,
+                "pulse_width": 0.8,
+                "phase_shift": 0.05,
+                "harmonics": [1.0, 0.4, 0.2, 0.1]
+            }
+        }
+        
+        # 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)
+        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"
+        }
+
+    def _generate_base_wave(self, duration):
+        """Generate the base carrier wave"""
+        t = np.linspace(0, duration, int(self.sample_rate * duration), endpoint=False)
+        return t, np.sin(2 * np.pi * self.base_freq * t)
+    
+    def _apply_sine_modulation(self, t, carrier):
+        """Apply sine wave modulation"""
+        mod_freq = self.config["mod_freq"]
+        mod_depth = self.config["mod_depth"]
+        
+        # Create modulation envelope
+        mod_env = 1.0 + mod_depth * np.sin(2 * np.pi * mod_freq * t + self.config["phase_shift"])
+        
+        # Apply modulation
+        return carrier * mod_env
+    
+    def _apply_pulse_modulation(self, t, carrier):
+        """Apply pulse modulation"""
+        mod_freq = self.config["mod_freq"]
+        mod_depth = self.config["mod_depth"]
+        pulse_width = self.config["pulse_width"]
+        
+        # Create pulse modulation envelope
+        pulse = signal.square(2 * np.pi * mod_freq * t, duty=pulse_width)
+        mod_env = 1.0 + mod_depth * pulse
+        
+        # Apply modulation
+        return carrier * mod_env
+    
+    def _apply_chirp_modulation(self, t, carrier):
+        """Apply frequency chirp modulation"""
+        mod_depth = self.config["mod_depth"]
+        
+        # Create chirp modulation with frequency that increases with time
+        start_freq = self.base_freq * (1 - mod_depth/2)
+        end_freq = self.base_freq * (1 + mod_depth/2)
+        
+        # Linear chirp
+        chirp = signal.chirp(t, start_freq, t[-1], end_freq)
+        
+        # Apply modulation
+        return chirp * carrier
+
+    def _apply_harmonics(self, t, wave):
+        """Apply harmonic overtones to enrich the sound"""
+        harmonics = self.config["harmonics"]
+        rich_wave = np.zeros_like(wave)
+        
+        for i, harmonic_amp in enumerate(harmonics):
+            harmonic_freq = self.base_freq * (i + 1)
+            rich_wave += harmonic_amp * np.sin(2 * np.pi * harmonic_freq * t)
+        
+        # Normalize
+        rich_wave = rich_wave / np.max(np.abs(rich_wave))
+        return rich_wave
+    
+    def generate_modulated_wave(self, duration):
+        """
+        Generate modulated audio wave based on current settings
+        
+        Args:
+            duration (float): Duration of audio in seconds
+            
+        Returns:
+            numpy.ndarray: The modulated audio waveform
+        """
+        t, carrier = self._generate_base_wave(duration)
+        
+        # Apply the selected modulation type
+        if self.modulation_type == "sine":
+            modulated = self._apply_sine_modulation(t, carrier)
+        elif self.modulation_type == "pulse":
+            modulated = self._apply_pulse_modulation(t, carrier)
+        elif self.modulation_type == "chirp":
+            modulated = self._apply_chirp_modulation(t, carrier)
+        else:
+            modulated = carrier  # Default to unmodulated carrier
+        
+        # Apply harmonics for richer sound
+        enriched = self._apply_harmonics(t, modulated)
+        
+        # Normalize to prevent clipping
+        normalized = 0.8 * enriched / np.max(np.abs(enriched))
+        
+        return normalized
+        
+    def visualize_waveform(self, duration):
+        """
+        Generate visualization of the modulated waveform
+        
+        Args:
+            duration (float): Duration of audio in seconds
+            
+        Returns:
+            matplotlib.figure.Figure: Figure containing the waveform visualization
+        """
+        # Generate a shorter segment for visualization
+        t = np.linspace(0, min(duration, 2), int(self.sample_rate * min(duration, 2)), endpoint=False)
+        
+        # Generate modulated wave for plotting
+        modulated = self.generate_modulated_wave(min(duration, 2))
+        
+        # Create visualization
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
+        
+        # Plot time domain
+        ax1.plot(t[:1000], modulated[:1000])
+        ax1.set_title(f'Rhythma Modulated Waveform: {self.rhythm_pattern} ({self.modulation_type})')
+        ax1.set_xlabel('Time (s)')
+        ax1.set_ylabel('Amplitude')
+        
+        # Plot frequency domain (spectrogram)
+        f, t, Sxx = signal.spectrogram(modulated, self.sample_rate)
+        ax2.pcolormesh(t, f[:500], Sxx[:500], shading='gouraud')
+        ax2.set_ylabel('Frequency (Hz)')
+        ax2.set_xlabel('Time (s)')
+        ax2.set_title('Spectrogram')
+        
+        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')
+        
+        return fig
+        
+    def get_symbolic_interpretation(self):
+        """Return the symbolic interpretation of the current rhythm pattern"""
+        return self.symbolic_mapping.get(self.rhythm_pattern, "Unknown pattern")