ss

beat_analysis.py

@@ -6,6 +6,7 @@ from functools import lru_cache
 import string
 from nltk.corpus import cmudict
 import nltk
+from scipy import signal
 
 try:
     nltk.data.find('corpora/cmudict')
@@ -126,9 +127,418 @@ class BeatAnalyzer:
             
         # Ensure at least one syllable
         return max(count, 1)
+
+    def detect_time_signature(self, audio_path, sr=22050):
+        """
+        Advanced multi-method approach to time signature detection
+        
+        Args:
+            audio_path: Path to audio file
+            sr: Sample rate
+        
+        Returns:
+            dict with detected time signature and confidence
+        """
+        # Load audio
+        y, sr = librosa.load(audio_path, sr=sr)
+        
+        # 1. Compute onset envelope and beat positions
+        onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=512)
+        
+        # Get tempo and beat frames
+        tempo, beat_frames = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
+        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+        
+        # Return default if not enough beats detected
+        if len(beat_times) < 8:
+            return {"time_signature": "4/4", "confidence": 0.5}
+        
+        # 2. Extract beat strengths and normalize
+        beat_strengths = self._get_beat_strengths(y, sr, beat_times, onset_env)
+        
+        # 3. Compute various time signature features using different methods
+        results = {}
+        
+        # Method 1: Beat pattern autocorrelation
+        autocorr_result = self._detect_by_autocorrelation(onset_env, sr)
+        results["autocorrelation"] = autocorr_result
+        
+        # Method 2: Beat strength pattern matching
+        pattern_result = self._detect_by_pattern_matching(beat_strengths)
+        results["pattern_matching"] = pattern_result
+        
+        # Method 3: Spectral rhythmic analysis
+        spectral_result = self._detect_by_spectral_analysis(onset_env, sr)
+        results["spectral"] = spectral_result
+        
+        # Method 4: Note density analysis
+        density_result = self._detect_by_note_density(y, sr, beat_times)
+        results["note_density"] = density_result
+        
+        # Method 5: Tempo-based estimation
+        tempo_result = self._estimate_from_tempo(tempo)
+        results["tempo_based"] = tempo_result
+        
+        # 4. Combine results with weighted voting
+        final_result = self._combine_detection_results(results, tempo)
+        
+        return final_result
+    
+    def _get_beat_strengths(self, y, sr, beat_times, onset_env):
+        """Extract normalized strengths at beat positions"""
+        # Convert beat times to frames
+        beat_frames = librosa.time_to_frames(beat_times, sr=sr, hop_length=512)
+        beat_frames = [min(f, len(onset_env)-1) for f in beat_frames]
+        
+        # Get beat strengths from onset envelope
+        beat_strengths = np.array([onset_env[f] for f in beat_frames])
+        
+        # Also look at energy and spectral flux at beat positions
+        hop_length = 512
+        frame_length = 2048
+        
+        # Get energy at each beat
+        energy = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length)[0]
+        beat_energy = np.array([energy[min(f, len(energy)-1)] for f in beat_frames])
+        
+        # Combine onset strength with energy (weighted average)
+        beat_strengths = 0.7 * beat_strengths + 0.3 * beat_energy
+        
+        # Normalize
+        if np.max(beat_strengths) > 0:
+            beat_strengths = beat_strengths / np.max(beat_strengths)
+            
+        return beat_strengths
+    
+    def _detect_by_autocorrelation(self, onset_env, sr):
+        """Detect meter using autocorrelation of onset strength"""
+        # Calculate autocorrelation of onset envelope
+        hop_length = 512
+        ac = librosa.autocorrelate(onset_env, max_size=4 * sr // hop_length)
+        ac = librosa.util.normalize(ac)
+        
+        # Find significant peaks in autocorrelation
+        peaks = signal.find_peaks(ac, height=0.2, distance=sr//(8*hop_length))[0]
+        
+        if len(peaks) < 2:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Analyze peak intervals in terms of beats
+        peak_intervals = np.diff(peaks)
+        
+        # Convert peaks to time
+        peak_times = peaks * hop_length / sr
+        
+        # Analyze for common time signature patterns
+        time_sig_votes = {}
+        
+        # Check if peaks match expected bar lengths
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            
+            # Check how well peaks match this meter
+            score = 0
+            for interval in peak_intervals:
+                # Check if this interval corresponds to this time signature
+                # Allow some tolerance around the expected value
+                expected = beats_per_bar * (hop_length / sr)  # in seconds
+                tolerance = 0.25 * expected
+                
+                if abs(interval * hop_length / sr - expected) < tolerance:
+                    score += 1
+            
+            if len(peak_intervals) > 0:
+                time_sig_votes[ts] = score / len(peak_intervals)
+        
+        # Return most likely time signature
+        if time_sig_votes:
+            best_ts = max(time_sig_votes.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        return {"time_signature": "4/4", "confidence": 0.4}
+    
+    def _detect_by_pattern_matching(self, beat_strengths):
+        """Match beat strength patterns against known time signature patterns"""
+        if len(beat_strengths) < 6:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        results = {}
+        
+        # Try each possible time signature
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            expected_pattern = info["beat_pattern"]
+            
+            # Calculate correlation scores for overlapping segments
+            scores = []
+            
+            # We need at least one complete pattern
+            if len(beat_strengths) >= beats_per_bar:
+                # Try different offsets to find best alignment
+                for offset in range(min(beats_per_bar, len(beat_strengths) - beats_per_bar + 1)):
+                    # Calculate scores for each complete pattern
+                    pattern_scores = []
+                    
+                    for i in range(offset, len(beat_strengths) - beats_per_bar + 1, beats_per_bar):
+                        segment = beat_strengths[i:i+beats_per_bar]
+                        
+                        # If expected pattern is longer than segment, truncate it
+                        pattern = expected_pattern[:len(segment)]
+                        
+                        # Normalize segment and pattern
+                        if np.std(segment) > 0 and np.std(pattern) > 0:
+                            # Calculate correlation
+                            corr = np.corrcoef(segment, pattern)[0, 1]
+                            if not np.isnan(corr):
+                                pattern_scores.append(corr)
+                    
+                    if pattern_scores:
+                        scores.append(np.mean(pattern_scores))
+            
+            # Use the best score among different offsets
+            if scores:
+                confidence = max(scores)
+                results[ts] = confidence
+        
+        # Find best match
+        if results:
+            best_ts = max(results.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default
+        return {"time_signature": "4/4", "confidence": 0.5}
+    
+    def _detect_by_spectral_analysis(self, onset_env, sr):
+        """Analyze rhythm in frequency domain"""
+        # Get rhythm periodicity through Fourier Transform
+        # Focus on periods corresponding to typical bar lengths (1-8 seconds)
+        hop_length = 512
+        
+        # Calculate rhythm periodicity
+        fft_size = 2**13  # Large enough to give good frequency resolution
+        S = np.abs(np.fft.rfft(onset_env, n=fft_size))
+        
+        # Convert frequency to tempo in BPM
+        freqs = np.fft.rfftfreq(fft_size, d=hop_length/sr)
+        tempos = 60 * freqs
+        
+        # Focus on reasonable tempo range (40-240 BPM)
+        tempo_mask = (tempos >= 40) & (tempos <= 240)
+        S_tempo = S[tempo_mask]
+        tempos = tempos[tempo_mask]
+        
+        # Find peaks in spectrum
+        peaks = signal.find_peaks(S_tempo, height=np.max(S_tempo)*0.1, distance=5)[0]
+
+        if len(peaks) == 0:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Get peak tempos and strengths
+        peak_tempos = tempos[peaks]
+        peak_strengths = S_tempo[peaks]
+        
+        # Sort by strength
+        peak_indices = np.argsort(peak_strengths)[::-1]
+        peak_tempos = peak_tempos[peak_indices]
+        peak_strengths = peak_strengths[peak_indices]
+        
+        # Analyze relationships between peaks
+        # For example, 3/4 typically has peaks at multiples of 3 beats
+        # 4/4 has peaks at multiples of 4 beats
+        
+        time_sig_scores = {}
+        
+        # Check relationships between top peaks
+        if len(peak_tempos) >= 2:
+            tempo_ratios = []
+            for i in range(len(peak_tempos)):
+                for j in range(i+1, len(peak_tempos)):
+                    if peak_tempos[j] > 0:
+                        ratio = peak_tempos[i] / peak_tempos[j]
+                        tempo_ratios.append(ratio)
+            
+            # Check for patterns indicative of different time signatures
+            for ts in self.common_time_signatures:
+                score = 0
+                
+                if ts == "4/4" or ts == "6/8":
+                    # Look for ratios close to 4 or 6
+                    for ratio in tempo_ratios:
+                        if abs(ratio - 4) < 0.2 or abs(ratio - 6) < 0.3:
+                            score += 1
+                
+                # Normalize score
+                if tempo_ratios:
+                    time_sig_scores[ts] = min(1.0, score / len(tempo_ratios) + 0.4)
+        
+        # If we have meaningful scores, return best match
+        if time_sig_scores:
+            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default fallback
+        return {"time_signature": "4/4", "confidence": 0.4}
     
-    def analyze_beat_pattern(self, audio_path, sr=22050, time_signature="4/4"):
+    def _detect_by_note_density(self, y, sr, beat_times):
+        """Analyze note density patterns between beats"""
+        if len(beat_times) < 6:
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Extract note onsets (not just beats)
+        onset_times = librosa.onset.onset_detect(y=y, sr=sr, units='time')
+        
+        if len(onset_times) < len(beat_times):
+            return {"time_signature": "4/4", "confidence": 0.4}
+            
+        # Count onsets between consecutive beats
+        note_counts = []
+        for i in range(len(beat_times) - 1):
+            start = beat_times[i]
+            end = beat_times[i+1]
+            
+            # Count onsets in this beat
+            count = sum(1 for t in onset_times if start <= t < end)
+            note_counts.append(count)
+        
+        # Look for repeating patterns in the note counts
+        time_sig_scores = {}
+        
+        for ts, info in self.common_time_signatures.items():
+            beats_per_bar = info["beats_per_bar"]
+            
+            # Skip if we don't have enough data
+            if len(note_counts) < beats_per_bar:
+                continue
+                
+            # Calculate pattern similarity for this time signature
+            scores = []
+            
+            for offset in range(min(beats_per_bar, len(note_counts) - beats_per_bar + 1)):
+                similarities = []
+                
+                for i in range(offset, len(note_counts) - beats_per_bar + 1, beats_per_bar):
+                    # Get current bar pattern
+                    pattern = note_counts[i:i+beats_per_bar]
+                    
+                    # Compare with expected density pattern
+                    expected = self.rhythm_density.get(ts, [1.0] * beats_per_bar)
+                    expected = expected[:len(pattern)]  # Truncate if needed
+                    
+                    # Normalize both patterns
+                    if sum(pattern) > 0 and sum(expected) > 0:
+                        pattern_norm = [p/max(1, sum(pattern)) for p in pattern]
+                        expected_norm = [e/sum(expected) for e in expected]
+                        
+                        # Calculate similarity (1 - distance)
+                        distance = sum(abs(p - e) for p, e in zip(pattern_norm, expected_norm)) / len(pattern)
+                        similarity = 1 - min(1.0, distance)
+                        similarities.append(similarity)
+                
+                if similarities:
+                    scores.append(np.mean(similarities))
+            
+            # Use the best score
+            if scores:
+                time_sig_scores[ts] = max(scores)
+        
+        # Return best match
+        if time_sig_scores:
+            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
+            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+        
+        # Default
+        return {"time_signature": "4/4", "confidence": 0.4}
+    
+    def _estimate_from_tempo(self, tempo):
+        """Use tempo to help estimate likely time signature"""
+        # Statistical tendencies: slower tempos often in compound meters (6/8)
+        # Fast tempos favor 4/4
+        
+        scores = {}
+        
+        if tempo < 70:
+            # Slow tempos favor compound meters
+            scores = {
+                "4/4": 0.5,
+                "3/4": 0.4,
+                "6/8": 0.7
+            }
+        elif 70 <= tempo <= 120:
+            # Medium tempos favor 4/4, 3/4
+            scores = {
+                "4/4": 0.7,
+                "3/4": 0.6,
+                "6/8": 0.3
+            }
+        else:
+            # Fast tempos favor 4/4
+            scores = {
+                "4/4": 0.8,
+                "3/4": 0.4,
+                "6/8": 0.2
+            }
+        
+        # Find best match
+        best_ts = max(scores.items(), key=lambda x: x[1])
+        return {"time_signature": best_ts[0], "confidence": best_ts[1]}
+    
+    def _combine_detection_results(self, results, tempo):
+        """Combine results from different detection methods"""
+        # Define weights for different methods
+        method_weights = {
+            "autocorrelation": 0.25,
+            "pattern_matching": 0.30,
+            "spectral": 0.20,
+            "note_density": 0.20,
+            "tempo_based": 0.05
+        }
+        
+        # Prior probability (based on frequency in music)
+        prior_weights = {ts: info["weight"] for ts, info in self.common_time_signatures.items()}
+        
+        # Combine votes
+        total_votes = {ts: prior_weights.get(ts, 0.1) for ts in self.common_time_signatures}
+        
+        for method, result in results.items():
+            ts = result["time_signature"]
+            confidence = result["confidence"]
+            weight = method_weights.get(method, 0.1)
+            
+            # Add weighted vote
+            if ts in total_votes:
+                total_votes[ts] += confidence * weight
+            else:
+                total_votes[ts] = confidence * weight
+        
+        # Special case: disambiguate between 3/4 and 6/8
+        if "3/4" in total_votes and "6/8" in total_votes:
+            # If the two are close, use tempo to break tie
+            if abs(total_votes["3/4"] - total_votes["6/8"]) < 0.1:
+                if tempo < 100:  # Slower tempo favors 6/8
+                    total_votes["6/8"] += 0.1
+                else:  # Faster tempo favors 3/4
+                    total_votes["3/4"] += 0.1
+        
+        # Get highest scoring time signature
+        best_ts = max(total_votes.items(), key=lambda x: x[1])
+        
+        # Calculate confidence score (normalize to 0-1)
+        confidence = best_ts[1] / (sum(total_votes.values()) + 0.001)
+        confidence = min(0.95, max(0.4, confidence))  # Bound confidence
+        
+        return {
+            "time_signature": best_ts[0],
+            "confidence": confidence,
+            "all_candidates": {ts: float(score) for ts, score in total_votes.items()}
+        }
+    
+    def analyze_beat_pattern(self, audio_path, sr=22050, time_signature="4/4", auto_detect=False):
         """Analyze beat patterns and stresses in music using the provided time signature."""
+        # Auto-detect time signature if requested
+        if auto_detect:
+            time_sig_result = self.detect_time_signature(audio_path, sr)
+            time_signature = time_sig_result["time_signature"]
+        
         # Load audio
         y, sr = librosa.load(audio_path, sr=sr)
         

emotionanalysis.py

@@ -9,9 +9,13 @@ except ImportError:
 from scipy.stats import mode
 import warnings
 warnings.filterwarnings('ignore')  # Suppress librosa warnings
+from beat_analysis import BeatAnalyzer  # Import BeatAnalyzer for rhythm analysis
 
 class MusicAnalyzer:
     def __init__(self):
+        # Create an instance of BeatAnalyzer for rhythm detection
+        self.beat_analyzer = BeatAnalyzer()
+        
         # Emotion feature mappings - these define characteristics of different emotions
         self.emotion_profiles = {
             'happy': {'tempo': (100, 180), 'energy': (0.6, 1.0), 'major_mode': True, 'brightness': (0.6, 1.0)},
@@ -34,28 +38,6 @@ class MusicAnalyzer:
 
         # Musical key mapping
         self.key_names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
-        
-        # Common time signatures and their beat patterns with weights for prior probability
-        # Simplified to only include 4/4, 3/4, and 6/8
-        self.common_time_signatures = {
-            "4/4": {"beats_per_bar": 4, "beat_pattern": [1.0, 0.2, 0.5, 0.2], "weight": 0.45},
-            "3/4": {"beats_per_bar": 3, "beat_pattern": [1.0, 0.2, 0.3], "weight": 0.25},
-            "6/8": {"beats_per_bar": 6, "beat_pattern": [1.0, 0.2, 0.3, 0.8, 0.2, 0.3], "weight": 0.30}
-        }
-        
-        # Add common accent patterns for different time signatures
-        self.accent_patterns = {
-            "4/4": [[1, 0, 0, 0], [1, 0, 2, 0], [1, 0, 2, 0, 3, 0, 2, 0]],
-            "3/4": [[1, 0, 0], [1, 0, 2]],
-            "6/8": [[1, 0, 0, 2, 0, 0], [1, 0, 0, 2, 0, 3]]
-        }
-        
-        # Expected rhythm density (relative note density per beat) for different time signatures
-        self.rhythm_density = {
-            "4/4": [1.0, 0.7, 0.8, 0.6],
-            "3/4": [1.0, 0.6, 0.7],
-            "6/8": [1.0, 0.5, 0.4, 0.8, 0.5, 0.4]
-        }
 
     def load_audio(self, file_path, sr=22050, duration=None):
         """Load audio file and return time series and sample rate"""
@@ -81,8 +63,16 @@ class MusicAnalyzer:
         ac = librosa.autocorrelate(onset_env, max_size=sr // 2)
         ac = librosa.util.normalize(ac, norm=np.inf)
 
-        # Advanced time signature detection
-        time_sig_result = self._detect_time_signature(y, sr)
+        # Use BeatAnalyzer for advanced time signature detection
+        # We need to save the audio temporarily to use the BeatAnalyzer method
+        import tempfile
+        import soundfile as sf
+        
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=True) as temp_file:
+            sf.write(temp_file.name, y, sr)
+            # Use BeatAnalyzer's advanced time signature detection
+            time_sig_result = self.beat_analyzer.detect_time_signature(temp_file.name)
         
         # Extract results from the time signature detection
         estimated_signature = time_sig_result["time_signature"]
@@ -110,485 +100,6 @@ class MusicAnalyzer:
             "time_signature_candidates": time_sig_result.get("all_candidates", {})
         }
 
-    def _detect_time_signature(self, y, sr):
-        """
-        Multi-method approach to time signature detection
-        
-        Args:
-            y: Audio signal
-            sr: Sample rate
-        
-        Returns:
-            dict with detected time signature and confidence
-        """
-        # 1. Compute onset envelope and beat positions
-        onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=512)
-        
-        # Get tempo and beat frames
-        tempo, beat_frames = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr)
-        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
-        
-        # Return default if not enough beats detected
-        if len(beat_times) < 8:
-            return {"time_signature": "4/4", "confidence": 0.5}
-        
-        # 2. Extract beat strengths and normalize
-        beat_strengths = self._get_beat_strengths(y, sr, beat_times, onset_env)
-        
-        # 3. Compute various time signature features using different methods
-        results = {}
-        
-        # Method 1: Beat pattern autocorrelation
-        autocorr_result = self._detect_by_autocorrelation(onset_env, sr)
-        results["autocorrelation"] = autocorr_result
-        
-        # Method 2: Beat strength pattern matching
-        pattern_result = self._detect_by_pattern_matching(beat_strengths)
-        results["pattern_matching"] = pattern_result
-        
-        # Method 3: Spectral rhythmic analysis
-        spectral_result = self._detect_by_spectral_analysis(onset_env, sr)
-        results["spectral"] = spectral_result
-        
-        # Method 4: Note density analysis
-        density_result = self._detect_by_note_density(y, sr, beat_times)
-        results["note_density"] = density_result
-        
-        # Method 5: Tempo-based estimation
-        tempo_result = self._estimate_from_tempo(tempo)
-        results["tempo_based"] = tempo_result
-        
-        # 4. Combine results with weighted voting
-        final_result = self._combine_detection_results(results, tempo)
-        
-        return final_result
-    
-    def _get_beat_strengths(self, y, sr, beat_times, onset_env):
-        """Extract normalized strengths at beat positions"""
-        # Convert beat times to frames
-        beat_frames = librosa.time_to_frames(beat_times, sr=sr, hop_length=512)
-        beat_frames = [min(f, len(onset_env)-1) for f in beat_frames]
-        
-        # Get beat strengths from onset envelope
-        beat_strengths = np.array([onset_env[f] for f in beat_frames])
-        
-        # Also look at energy and spectral flux at beat positions
-        hop_length = 512
-        frame_length = 2048
-        
-        # Get energy at each beat
-        energy = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length)[0]
-        beat_energy = np.array([energy[min(f, len(energy)-1)] for f in beat_frames])
-        
-        # Combine onset strength with energy (weighted average)
-        beat_strengths = 0.7 * beat_strengths + 0.3 * beat_energy
-        
-        # Normalize
-        if np.max(beat_strengths) > 0:
-            beat_strengths = beat_strengths / np.max(beat_strengths)
-            
-        return beat_strengths
-    
-    def _detect_by_autocorrelation(self, onset_env, sr):
-        """Detect meter using autocorrelation of onset strength"""
-        # Calculate autocorrelation of onset envelope
-        hop_length = 512
-        ac = librosa.autocorrelate(onset_env, max_size=4 * sr // hop_length)
-        ac = librosa.util.normalize(ac)
-        
-        # Find significant peaks in autocorrelation
-        peaks = signal.find_peaks(ac, height=0.2, distance=sr//(8*hop_length))[0]
-        
-        if len(peaks) < 2:
-            return {"time_signature": "4/4", "confidence": 0.4}
-            
-        # Analyze peak intervals in terms of beats
-        peak_intervals = np.diff(peaks)
-        
-        # Convert peaks to time
-        peak_times = peaks * hop_length / sr
-        
-        # Analyze for common time signature patterns
-        time_sig_votes = {}
-        
-        # Check if peaks match expected bar lengths
-        for ts, info in self.common_time_signatures.items():
-            beats_per_bar = info["beats_per_bar"]
-            
-            # Check how well peaks match this meter
-            score = 0
-            for interval in peak_intervals:
-                # Check if this interval corresponds to this time signature
-                # Allow some tolerance around the expected value
-                expected = beats_per_bar * (hop_length / sr)  # in seconds
-                tolerance = 0.25 * expected
-                
-                if abs(interval * hop_length / sr - expected) < tolerance:
-                    score += 1
-            
-            if len(peak_intervals) > 0:
-                time_sig_votes[ts] = score / len(peak_intervals)
-        
-        # Return most likely time signature
-        if time_sig_votes:
-            best_ts = max(time_sig_votes.items(), key=lambda x: x[1])
-            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
-        
-        return {"time_signature": "4/4", "confidence": 0.4}
-    
-    def _detect_by_pattern_matching(self, beat_strengths):
-        """Match beat strength patterns against known time signature patterns"""
-        if len(beat_strengths) < 6:
-            return {"time_signature": "4/4", "confidence": 0.4}
-            
-        results = {}
-        
-        # Try each possible time signature
-        for ts, info in self.common_time_signatures.items():
-            beats_per_bar = info["beats_per_bar"]
-            expected_pattern = info["beat_pattern"]
-            
-            # Calculate correlation scores for overlapping segments
-            scores = []
-            
-            # We need at least one complete pattern
-            if len(beat_strengths) >= beats_per_bar:
-                # Try different offsets to find best alignment
-                for offset in range(min(beats_per_bar, len(beat_strengths) - beats_per_bar + 1)):
-                    # Calculate scores for each complete pattern
-                    pattern_scores = []
-                    
-                    for i in range(offset, len(beat_strengths) - beats_per_bar + 1, beats_per_bar):
-                        segment = beat_strengths[i:i+beats_per_bar]
-                        
-                        # If expected pattern is longer than segment, truncate it
-                        pattern = expected_pattern[:len(segment)]
-                        
-                        # Normalize segment and pattern
-                        if np.std(segment) > 0 and np.std(pattern) > 0:
-                            # Calculate correlation
-                            corr = np.corrcoef(segment, pattern)[0, 1]
-                            if not np.isnan(corr):
-                                pattern_scores.append(corr)
-                    
-                    if pattern_scores:
-                        scores.append(np.mean(pattern_scores))
-            
-            # Use the best score among different offsets
-            if scores:
-                confidence = max(scores)
-                results[ts] = confidence
-        
-        # Find best match
-        if results:
-            best_ts = max(results.items(), key=lambda x: x[1])
-            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
-        
-        # Default
-        return {"time_signature": "4/4", "confidence": 0.5}
-    
-    def _detect_by_spectral_analysis(self, onset_env, sr):
-        """Analyze rhythm in frequency domain"""
-        # Get rhythm periodicity through Fourier Transform
-        # Focus on periods corresponding to typical bar lengths (1-8 seconds)
-        hop_length = 512
-        
-        # Calculate rhythm periodicity
-        fft_size = 2**13  # Large enough to give good frequency resolution
-        S = np.abs(np.fft.rfft(onset_env, n=fft_size))
-        
-        # Convert frequency to tempo in BPM
-        freqs = np.fft.rfftfreq(fft_size, d=hop_length/sr)
-        tempos = 60 * freqs
-        
-        # Focus on reasonable tempo range (40-240 BPM)
-        tempo_mask = (tempos >= 40) & (tempos <= 240)
-        S_tempo = S[tempo_mask]
-        tempos = tempos[tempo_mask]
-        
-        # Find peaks in spectrum
-        peaks = signal.find_peaks(S_tempo, height=np.max(S_tempo)*0.1, distance=5)[0]
-
-        if len(peaks) == 0:
-            return {"time_signature": "4/4", "confidence": 0.4}
-            
-        # Get peak tempos and strengths
-        peak_tempos = tempos[peaks]
-        peak_strengths = S_tempo[peaks]
-        
-        # Sort by strength
-        peak_indices = np.argsort(peak_strengths)[::-1]
-        peak_tempos = peak_tempos[peak_indices]
-        peak_strengths = peak_strengths[peak_indices]
-        
-        # Analyze relationships between peaks
-        # For example, 3/4 typically has peaks at multiples of 3 beats
-        # 4/4 has peaks at multiples of 4 beats
-        
-        time_sig_scores = {}
-        
-        # Check relationships between top peaks
-        if len(peak_tempos) >= 2:
-            tempo_ratios = []
-            for i in range(len(peak_tempos)):
-                for j in range(i+1, len(peak_tempos)):
-                    if peak_tempos[j] > 0:
-                        ratio = peak_tempos[i] / peak_tempos[j]
-                        tempo_ratios.append(ratio)
-            
-            # Check for patterns indicative of different time signatures
-            for ts in self.common_time_signatures:
-                score = 0
-                
-                if ts == "4/4" or ts == "6/8":
-                    # Look for ratios close to 4 or 6
-                    for ratio in tempo_ratios:
-                        if abs(ratio - 4) < 0.2 or abs(ratio - 6) < 0.3:
-                            score += 1
-                
-                # Normalize score
-                if tempo_ratios:
-                    time_sig_scores[ts] = min(1.0, score / len(tempo_ratios) + 0.4)
-        
-        # If we have meaningful scores, return best match
-        if time_sig_scores:
-            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
-            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
-        
-        # Default fallback
-        return {"time_signature": "4/4", "confidence": 0.4}
-    
-    def _detect_by_note_density(self, y, sr, beat_times):
-        """Analyze note density patterns between beats"""
-        if len(beat_times) < 6:
-            return {"time_signature": "4/4", "confidence": 0.4}
-            
-        # Extract note onsets (not just beats)
-        onset_times = librosa.onset.onset_detect(y=y, sr=sr, units='time')
-        
-        if len(onset_times) < len(beat_times):
-            return {"time_signature": "4/4", "confidence": 0.4}
-            
-        # Count onsets between consecutive beats
-        note_counts = []
-        for i in range(len(beat_times) - 1):
-            start = beat_times[i]
-            end = beat_times[i+1]
-            
-            # Count onsets in this beat
-            count = sum(1 for t in onset_times if start <= t < end)
-            note_counts.append(count)
-        
-        # Look for repeating patterns in the note counts
-        time_sig_scores = {}
-        
-        for ts, info in self.common_time_signatures.items():
-            beats_per_bar = info["beats_per_bar"]
-            
-            # Skip if we don't have enough data
-            if len(note_counts) < beats_per_bar:
-                continue
-                
-            # Calculate pattern similarity for this time signature
-            scores = []
-            
-            for offset in range(min(beats_per_bar, len(note_counts) - beats_per_bar + 1)):
-                similarities = []
-                
-                for i in range(offset, len(note_counts) - beats_per_bar + 1, beats_per_bar):
-                    # Get current bar pattern
-                    pattern = note_counts[i:i+beats_per_bar]
-                    
-                    # Compare with expected density pattern
-                    expected = self.rhythm_density.get(ts, [1.0] * beats_per_bar)
-                    expected = expected[:len(pattern)]  # Truncate if needed
-                    
-                    # Normalize both patterns
-                    if sum(pattern) > 0 and sum(expected) > 0:
-                        pattern_norm = [p/max(1, sum(pattern)) for p in pattern]
-                        expected_norm = [e/sum(expected) for e in expected]
-                        
-                        # Calculate similarity (1 - distance)
-                        distance = sum(abs(p - e) for p, e in zip(pattern_norm, expected_norm)) / len(pattern)
-                        similarity = 1 - min(1.0, distance)
-                        similarities.append(similarity)
-                
-                if similarities:
-                    scores.append(np.mean(similarities))
-            
-            # Use the best score
-            if scores:
-                time_sig_scores[ts] = max(scores)
-        
-        # Return best match
-        if time_sig_scores:
-            best_ts = max(time_sig_scores.items(), key=lambda x: x[1])
-            return {"time_signature": best_ts[0], "confidence": best_ts[1]}
-        
-        # Default
-        return {"time_signature": "4/4", "confidence": 0.4}
-    
-    def _estimate_from_tempo(self, tempo):
-        """Use tempo to help estimate likely time signature"""
-        # Statistical tendencies: slower tempos often in compound meters (6/8)
-        # Fast tempos favor 4/4
-        
-        scores = {}
-        
-        if tempo < 70:
-            # Slow tempos favor compound meters
-            scores = {
-                "4/4": 0.5,
-                "3/4": 0.4,
-                "6/8": 0.7
-            }
-        elif 70 <= tempo <= 120:
-            # Medium tempos favor 4/4, 3/4
-            scores = {
-                "4/4": 0.7,
-                "3/4": 0.6,
-                "6/8": 0.3
-            }
-        else:
-            # Fast tempos favor 4/4
-            scores = {
-                "4/4": 0.8,
-                "3/4": 0.4,
-                "6/8": 0.2
-            }
-        
-        # Find best match
-        best_ts = max(scores.items(), key=lambda x: x[1])
-        return {"time_signature": best_ts[0], "confidence": best_ts[1]}
-    
-    def _combine_detection_results(self, results, tempo):
-        """Combine results from different detection methods"""
-        # Define weights for different methods
-        method_weights = {
-            "autocorrelation": 0.25,
-            "pattern_matching": 0.30,
-            "spectral": 0.20,
-            "note_density": 0.20,
-            "tempo_based": 0.05
-        }
-        
-        # Prior probability (based on frequency in music)
-        prior_weights = {ts: info["weight"] for ts, info in self.common_time_signatures.items()}
-        
-        # Combine votes
-        total_votes = {ts: prior_weights.get(ts, 0.1) for ts in self.common_time_signatures}
-        
-        for method, result in results.items():
-            ts = result["time_signature"]
-            confidence = result["confidence"]
-            weight = method_weights.get(method, 0.1)
-            
-            # Add weighted vote
-            if ts in total_votes:
-                total_votes[ts] += confidence * weight
-            else:
-                total_votes[ts] = confidence * weight
-        
-        # Special case: disambiguate between 3/4 and 6/8
-        if "3/4" in total_votes and "6/8" in total_votes:
-            # If the two are close, use tempo to break tie
-            if abs(total_votes["3/4"] - total_votes["6/8"]) < 0.1:
-                if tempo < 100:  # Slower tempo favors 6/8
-                    total_votes["6/8"] += 0.1
-                else:  # Faster tempo favors 3/4
-                    total_votes["3/4"] += 0.1
-        
-        # Get highest scoring time signature
-        best_ts = max(total_votes.items(), key=lambda x: x[1])
-        
-        # Calculate confidence score (normalize to 0-1)
-        confidence = best_ts[1] / (sum(total_votes.values()) + 0.001)
-        confidence = min(0.95, max(0.4, confidence))  # Bound confidence
-        
-        return {
-            "time_signature": best_ts[0],
-            "confidence": confidence,
-            "all_candidates": {ts: float(score) for ts, score in total_votes.items()}
-        }
-    
-    def _evaluate_beat_pattern(self, beat_strengths, pattern_length):
-        """
-        Evaluate how consistently a specific pattern length fits the beat strengths
-        
-        Args:
-            beat_strengths: Array of normalized beat strengths
-            pattern_length: Length of pattern to evaluate
-            
-        Returns:
-            score: How well this pattern length explains the data (0-1)
-        """
-        if len(beat_strengths) < pattern_length * 2:
-            return 0.0
-            
-        # Calculate correlation between consecutive patterns
-        correlations = []
-        
-        num_full_patterns = len(beat_strengths) // pattern_length
-        for i in range(num_full_patterns - 1):
-            pattern1 = beat_strengths[i*pattern_length:(i+1)*pattern_length]
-            pattern2 = beat_strengths[(i+1)*pattern_length:(i+2)*pattern_length]
-            
-            # Calculate similarity between consecutive patterns
-            if len(pattern1) == len(pattern2) and len(pattern1) > 0:
-                corr = np.corrcoef(pattern1, pattern2)[0, 1]
-                if not np.isnan(corr):
-                    correlations.append(corr)
-        
-        # Calculate variance of beat strengths within each position
-        variance_score = 0
-        if num_full_patterns >= 2:
-            position_values = [[] for _ in range(pattern_length)]
-            
-            for i in range(num_full_patterns):
-                for pos in range(pattern_length):
-                    idx = i * pattern_length + pos
-                    if idx < len(beat_strengths):
-                        position_values[pos].append(beat_strengths[idx])
-            
-            # Calculate variance ratio (higher means consistent accent patterns)
-            between_pos_var = np.var([np.mean(vals) for vals in position_values if vals])
-            within_pos_var = np.mean([np.var(vals) for vals in position_values if len(vals) > 1])
-            
-            if within_pos_var > 0:
-                variance_score = between_pos_var / within_pos_var
-                variance_score = min(1.0, variance_score / 2.0)  # Normalize
-        
-        # Combine correlation and variance scores
-        if correlations:
-            correlation_score = np.mean(correlations)
-            return 0.7 * correlation_score + 0.3 * variance_score
-        
-        return 0.5 * variance_score  # Lower confidence if we couldn't calculate correlations
-    
-    def _extract_average_pattern(self, beat_strengths, pattern_length):
-        """
-        Extract the average beat pattern of specified length
-        
-        Args:
-            beat_strengths: Array of beat strengths
-            pattern_length: Length of pattern to extract
-            
-        Returns:
-            Average pattern of the specified length
-        """
-        if len(beat_strengths) < pattern_length:
-            return np.array([])
-            
-        # Number of complete patterns
-        num_patterns = len(beat_strengths) // pattern_length
-        
-        if num_patterns == 0:
-            return np.array([])
-            
-        # Reshape to stack patterns and calculate average
-        patterns = beat_strengths[:num_patterns * pattern_length].reshape((num_patterns, pattern_length))
-        return np.mean(patterns, axis=0)
-
     def analyze_tonality(self, y, sr):
         """Analyze tonal features: key, mode, harmonic features"""
         # Compute chromagram