added analysis

app.py

@@ -12,7 +12,8 @@ import random
 import mdpd
 import os
 
-from utils import getaudiodata, getBeats, plotBeattimes, find_s1s2
+#from utils import getaudiodata, getBeats, plotBeattimes, find_s1s2
+import utils as u
 
 example_dir = "Examples"
 example_files = [os.path.join(example_dir, f) for f in os.listdir(example_dir) if f.endswith(('.wav', '.mp3', '.ogg'))]
@@ -20,6 +21,10 @@ all_pairs = list(itertools.combinations(example_files, 2))
 random.shuffle(all_pairs)
 example_pairs = [list(pair) for pair in all_pairs[:25]]
 
+
+#-----------------------------------------------
+# PROCESSING FUNCTIONS
+#-----------------------------------------------
 def getHRV(beattimes: np.ndarray) -> np.ndarray:
     # Calculate instantaneous heart rate
     instantaneous_hr = 60 * np.diff(beattimes)
@@ -67,7 +72,7 @@ def create_average_heartbeat(audiodata, sr):
 # HELPER FUNCTIONS FOR SINGLE AUDIO ANALYSIS
 def plotCombined(audiodata, sr, filename):
     # Get beat times
-    tempo, beattimes = getBeats(audiodata, sr)
+    tempo, beattimes = u.getBeats(audiodata, sr)
     
     # Create subplots
     fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
@@ -135,7 +140,7 @@ def analyze_single(audio:gr.Audio):
     filename = filepath.split("/")[-1]
 
 
-    sr, audiodata = getaudiodata(filepath)
+    sr, audiodata = u.getaudiodata(filepath)
 
 
     # Now you have:
@@ -154,7 +159,7 @@ def analyze_single(audio:gr.Audio):
     rms = librosa.feature.rms(y=audiodata)[0]
     # print(f"Mean RMS Energy: {np.mean(rms):.4f}")
 
-    tempo, beattimes = getBeats(audiodata, sr)
+    tempo, beattimes = u.getBeats(audiodata, sr)
     spectogram_wave = plotCombined(audiodata, sr, filename)
     #beats_histogram = plotbeatscatter(tempo[0], beattimes)
 
@@ -180,19 +185,207 @@ def analyze_single(audio:gr.Audio):
     - Mean Beat Duration: {np.mean(np.diff(beattimes)):.4f}
     """
     return results, spectogram_wave, avg_beat_plot
+
 #-----------------------------------------------
+# ANALYSIS FUNCTIONS
 #-----------------------------------------------
 
+# - [ ]  Berechnungen Pro Segement:
+#     - [ ]  RMS Energy
+#     - [ ]  Frequenzen
+#     - [ ]  Dauer
+#     - [ ]  S2 - wenn möglich
+#         - [ ]  Dauer S1 bis S2 (S1)
+#         - [ ]  Dauer S2 bis S1 (S2)
+# - [ ]  Visualisierungen pro Datei:
+#     - [ ]  Waveform
+#     - [ ]  Spectogram
+#     - [ ]  HRV
+#     - [ ]  Avg. Heartbeat Waveform (fixe y-achse)
+#     - [ ]  Alle Segmente als Waveform übereinanderlegen (fixe y-achse +-0.05)
+# - [ ]  Daten Exportierbar machen
+# - [ ]  Einheiten für (RMS Energy, Energy)
+# - [ ]  wichtige Einheiten (Energy, RMS Energy, Sample Rate, Audio length, Beats, Beats durations)
+
+
+def get_visualizations(beattimes_table: str, cleanedaudio: gr.Audio):
+
+    df = mdpd.from_md(beattimes_table)
+    df['Beattimes'] = df['Beattimes'].astype(float)
+    df['Label (S1=1/S2=0)'] = df['Label (S1=1/S2=0)'].astype(int)
+
+    sr, audiodata = cleanedaudio
+    
+    segment_metrics = u.compute_segment_metrics(df, sr, audiodata)
+
+
+
+    # Normalize audio data from int16 to float in range [-1, 1]
+    audiodata = audiodata.astype(np.float32) / 32768.0
+
+    # Create figure with secondary y-axes
+    fig = make_subplots(
+        rows=5, cols=1,
+        subplot_titles=('Waveform', 'Spectrogram', 'Heart Rate Variability', 
+                       'Average Heartbeat Waveform', 'Overlaid Segments'),
+        vertical_spacing=0.1,
+        row_heights=[0.2, 0.2, 0.2, 0.2, 0.2]
+    )
+
+    # 1. Waveform
+    time = np.arange(len(audiodata)) / sr
+    fig.add_trace(
+        go.Scatter(x=time, y=audiodata, name='Waveform', line=dict(color='blue', width=1)),
+        row=1, col=1
+    )
+
+
+    # 2. Spectrogram
+    D = librosa.stft(audiodata)
+    frequencies = librosa.fft_frequencies(sr=sr)  # Get frequency values for y-axis
+    S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)
+    times = librosa.times_like(S_db, sr=sr)  # Get time values for x-axis
+
+    # Find index corresponding to 200 Hz
+    freq_mask = frequencies <= 1000
+    S_db_cropped = S_db[freq_mask]
+    frequencies_cropped = frequencies[freq_mask]
+
+    fig.add_trace(
+        go.Heatmap(
+            z=S_db_cropped,
+            x=times,
+            y=frequencies_cropped,  # Add frequencies to y-axis
+            colorscale='Viridis',
+            name='Spectrogram'
+        ),
+        row=2, col=1
+    )
+
+    # 3. HRV (Heart Rate Variability)
+    s1_durations = []
+    s2_durations = []
+    for segment in segment_metrics:
+        if segment['s1_to_s2_duration']:  # Check if list is not empty
+            s1_durations.extend(segment['s1_to_s2_duration'])
+        if segment['s2_to_s1_duration']:  # Check if list is not empty
+            s2_durations.extend(segment['s2_to_s1_duration'])
+
+    t_interp, sdnn_interp, rmssd_interp, hr_interp = u.compute_and_plot_hrv(s1_durations, s2_durations, sr)
+
+    # Add each HRV metric as a separate trace
+    fig.add_trace(
+        go.Scatter(
+            x=t_interp, 
+            y=sdnn_interp, 
+            name='SDNN', 
+            line=dict(color='red', width=1)
+        ),
+        row=3, col=1
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=t_interp, 
+            y=rmssd_interp, 
+            name='RMSSD', 
+            line=dict(color='blue', width=1)
+        ),
+        row=3, col=1
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=t_interp, 
+            y=hr_interp, 
+            name='Heart Rate', 
+            line=dict(color='green', width=1),
+            yaxis='y2'  # Use secondary y-axis for heart rate
+        ),
+        row=3, col=1
+    )
+
+
+    # 4. Average Heartbeat Waveform
+    max_len = max(len(metric['segment']) for metric in segment_metrics)
+    aligned_segments = []
+    
+    for metric in segment_metrics:
+        segment = metric['segment']
+        segment = segment.astype(np.float32) / 32768.0
+        padded = np.pad(segment, (0, max_len - len(segment)))
+        aligned_segments.append(padded)
+    
+    avg_waveform = np.mean(aligned_segments, axis=0)
+    time_avg = np.arange(len(avg_waveform)) / sr
+
+    fig.add_trace(
+        go.Scatter(x=time_avg, y=avg_waveform, name='Average Heartbeat', 
+                  line=dict(color='green', width=1)),
+        row=4, col=1
+    )
+
+    # 5. Overlaid Segments
+    colors = [
+        '#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3', 
+        '#fdb462', '#b3de69', '#fccde5', '#d9d9d9', '#bc80bd'
+    ]
+
+    # Then in the loop for overlaid segments:
+    for i, metric in enumerate(segment_metrics):
+        segment = metric['segment']
+        segment = segment.astype(np.float32) / 32768.0
+        time_segment = np.arange(len(segment)) / sr
+        
+        fig.add_trace(
+            go.Scatter(
+                x=time_segment,
+                y=segment,
+                name=f'Segment {i+1}',
+                opacity=0.3,
+                line=dict(color=colors[i % len(colors)], width=1)
+            ),
+            row=5, col=1
+        )
+
+    # Update layout
+    fig.update_layout(
+        height=1500,
+        showlegend=False,
+        title_text="",
+        plot_bgcolor='white',
+        paper_bgcolor='white'
+    )
+
+
+    # Update y-axes for fixed scales where needed
+    # fig.update_yaxes(range=[-0.05, 0.05], row=5, col=1)  # Fixed y-axis for overlaid segments
+    fig.update_yaxes(title_text="Amplitude", row=1, col=1, gridcolor='lightgray')
+    fig.update_yaxes(title_text="Frequency (Hz)", row=2, col=1)
+    fig.update_yaxes(title_text="Duration (s)", row=3, col=1, gridcolor='lightgray')
+    fig.update_yaxes(title_text="Amplitude", row=4, col=1, gridcolor='lightgray')
+    fig.update_yaxes(title_text="Amplitude", row=5, col=1, gridcolor='lightgray')
+
+    # Update x-axes
+    fig.update_xaxes(title_text="Time (s)", row=1, col=1, gridcolor='lightgray')
+    fig.update_xaxes(title_text="Time (s)", row=2, col=1)
+    fig.update_xaxes(title_text="Time (s)", row=3, col=1, gridcolor='lightgray')
+    fig.update_xaxes(title_text="Time (s)", row=4, col=1, gridcolor='lightgray')
+    fig.update_xaxes(title_text="Time (s)", row=5, col=1, gridcolor='lightgray')
+
+    return fig
+#-----------------------------------------------
+#-----------------------------------------------
 # HELPER FUNCTIONS FOR SINGLE AUDIO ANALYSIS V2
 
 def getBeatsv2(audio:gr.Audio):
 
-    sr, audiodata = getaudiodata(audio)
-    _, beattimes, audiodata = getBeats(audiodata, sr)
+    sr, audiodata = u.getaudiodata(audio)
+    _, beattimes, audiodata = u.getBeats(audiodata, sr)
 
     beattimes_table = pd.DataFrame(data={"Beattimes":beattimes})
 
-    feature_array = find_s1s2(beattimes_table)
+    feature_array = u.find_s1s2(beattimes_table)
 
     featuredf = pd.DataFrame(
         data=feature_array,
@@ -200,7 +393,7 @@ def getBeatsv2(audio:gr.Audio):
         "Beattimes",
         "S1 to S2",
         "S2 to S1",
-        "Label (S1=0/S2=1)"]
+        "Label (S1=1/S2=0)"]
     )
 
     # Create boolean masks for each label
@@ -211,7 +404,7 @@ def getBeatsv2(audio:gr.Audio):
     times_label_one = feature_array[mask_ones, 0]
     times_label_zero = feature_array[mask_zeros, 0]
 
-    fig = plotBeattimes(times_label_one, audiodata, sr, times_label_zero)
+    fig = u.plotBeattimes(times_label_one, audiodata, sr, times_label_zero)
 
 
     featuredf = featuredf.drop(columns=["S1 to S2", "S2 to S1"])
@@ -221,7 +414,7 @@ def getBeatsv2(audio:gr.Audio):
 
 def updateBeatsv2(audio:gr.Audio, uploadeddf:gr.File=None)-> go.Figure:
 
-    sr, audiodata = getaudiodata(audio)
+    sr, audiodata = u.getaudiodata(audio)
 
 
     if uploadeddf != None:
@@ -233,10 +426,10 @@ def updateBeatsv2(audio:gr.Audio, uploadeddf:gr.File=None)-> go.Figure:
     else:
         raise FileNotFoundError("No file uploaded")
 
-    s1_times = beattimes_table[beattimes_table["Label (S1=0/S2=1)"] == 0]["Beattimes"].to_numpy()
-    s2_times = beattimes_table[beattimes_table["Label (S1=0/S2=1)"] == 1]["Beattimes"].to_numpy()
+    s1_times = beattimes_table[beattimes_table["Label (S1=1/S2=0)"] == 0]["Beattimes"].to_numpy()
+    s2_times = beattimes_table[beattimes_table["Label (S1=1/S2=0)"] == 1]["Beattimes"].to_numpy()
 
-    fig = plotBeattimes(s1_times, audiodata, sr, s2_times)
+    fig = u.plotBeattimes(s1_times, audiodata, sr, s2_times)
 
     return fig, beattimes_table.to_markdown()
 
@@ -244,7 +437,7 @@ def download_df (beattimes_table: str):
 
     df = mdpd.from_md(beattimes_table)
     df['Beattimes'] = df['Beattimes'].astype(float)
-    df['Label (S1=0/S2=1)'] = df['Label (S1=0/S2=1)'].astype(int)
+    df['Label (S1=1/S2=0)'] = df['Label (S1=1/S2=0)'].astype(int)
 
 
     temp_dir = tempfile.gettempdir()
@@ -253,7 +446,7 @@ def download_df (beattimes_table: str):
     
     df.to_csv(
         index=False,
-        columns=["Beattimes", "Label (S1=0/S2=1)"],
+        columns=["Beattimes", "Label (S1=1/S2=0)"],
         path_or_buf=temp_path, 
         sep=";",
         decimal=",",
@@ -316,5 +509,11 @@ with gr.Blocks() as app:
 
         gr.Markdown("🚨 Please make sure to first run the 'Preprocessing'")
 
+        analyzebtn = gr.Button("Analyze Audio")
+
+        plot = gr.Plot()
+
+        analyzebtn.click(get_visualizations, inputs=[beattimes_table, cleanedaudio], outputs=[plot])
+
 
 app.launch()

utils.py

@@ -7,6 +7,8 @@ from sklearn.cluster import KMeans
 from sklearn.preprocessing import StandardScaler
 import pywt
 import pandas as pd
+from scipy.interpolate import interp1d
+
 
 
 # GENERAL HELPER FUNCTIONS
@@ -71,7 +73,7 @@ def denoise_audio(audiodata: np.ndarray, sr: int) -> tuple[np.ndarray, int]:
     
     # Ensure consistent length
     if len(denoised) != len(audio):
-        denoised = librosa.util.fix_length(denoised, len(audio))
+        denoised = librosa.util.fix_length(denoised, size=len(audio))
     
     # 3. Improved Spectral Subtraction
     def spectral_subtract(sig):
@@ -442,30 +444,47 @@ def plotBeattimes(beattimes: np.ndarray,
 
 def iterate_beat_segments(beat_times, sr, audio):
     """
-    Iterate over audio segments between beats.
+    Iterate over audio segments between beats marked with label 1.
     
     Parameters:
-    - beat_times: np.ndarray of beat times in seconds
+    - beat_times: df of beattimes and labels as DataFrame
     - sr: Sample rate of the audio
     - audio: np.ndarray of audio data
     
     Yields:
-    - Tuple of (start_sample, end_sample, audio_segment)
+    - List of segment metrics with associated beat information
     """
-    # Convert beat times to sample indices
-    beat_samples = librosa.time_to_samples(beat_times, sr=sr)
     
-    # Add start and end points
-    beat_samples = np.concatenate(([0], beat_samples, [len(audio)]))
+    # Get indices where label is 1
+    label_ones = beat_times[beat_times['Label (S1=1/S2=0)'] == 1].index.tolist()
+    
+    segment_metrics = []
     
-    # Iterate over pairs of beat samples
-    for start, end in zip(beat_samples[:-1], beat_samples[1:]):
-        # Extract the audio segment
-        segment = audio[start:end]
+    # Iterate through pairs of label 1 indices
+    for i in range(len(label_ones) - 1):
+        start_idx = label_ones[i]
+        end_idx = label_ones[i + 1]
+        
+        # Get all beats between two label 1 beats (inclusive)
+        segment_beats = beat_times.iloc[start_idx:end_idx + 1]
+        
+        # Create list of tuples (label, beattime)
+        beat_info = list(zip(segment_beats['Label (S1=1/S2=0)'], 
+                           segment_beats['Beattimes']))
+        
+        # Get start and end samples
+        start_sample = librosa.time_to_samples(segment_beats.iloc[0]['Beattimes'], sr=sr)
+        end_sample = librosa.time_to_samples(segment_beats.iloc[-1]['Beattimes'], sr=sr)
+        
+        # Extract audio segment
+        segment = audio[start_sample:end_sample]
+        
+        # Analyze segment with beat information
+        segment_metrics.append(segment_analysis(segment, sr, beat_info))
 
-        segment_metrics = segment_analysis(segment, sr)
+    return segment_metrics
 
-def segment_analysis(segment, sr):
+def segment_analysis(segment, sr, s1s2:list):
     """
     Analyze an audio segment and compute various metrics.
     
@@ -487,25 +506,28 @@ def segment_analysis(segment, sr):
     fft_magnitudes = np.abs(np.fft.rfft(segment))
     mean_frequency = np.mean(fft_magnitudes)
     
-    # Attempt to detect S1 and S2
-    # This is a simplified approach and may not be accurate for all cases
-    peaks, _ = find_peaks(np.abs(segment), distance=int(0.2*sr))  # Assume at least 0.2s between peaks
+    s1_to_s2_duration = []
+    s2_to_s1_duration = []
+
+    prev = s1s2[0]
+    for i in range(1, len(s1s2)):
+        if prev[0] == 0 and s1s2[i][0] == 1:
+            s2_to_s1_duration.append(s1s2[i][1] - prev[1])
+        elif prev[0] == 1 and s1s2[i][0] == 0:
+            s1_to_s2_duration.append(s1s2[i][1] - prev[1])
+        prev = s1s2[i]
+
+
+
     
-    if len(peaks) >= 2:
-        s1_index, s2_index = peaks[:2]
-        s1_to_s2_duration = (s2_index - s1_index) / sr
-        s2_to_s1_duration = (len(segment) - s2_index + peaks[0]) / sr if len(peaks) > 2 else None
-    else:
-        s1_to_s2_duration = None
-        s2_to_s1_duration = None
-    
-    return [
-        rms_energy,
-        mean_frequency,
-        duration,
-        s1_to_s2_duration,
-        s2_to_s1_duration
-    ]
+    return {
+        "rms_energy": rms_energy,
+        "mean_frequency": mean_frequency,
+        "duration": duration,
+        "s1_to_s2_duration": s1_to_s2_duration,
+        "s2_to_s1_duration": s2_to_s1_duration,
+        "segment": segment
+    }
 
 def find_s1s2(df:pd.DataFrame):
 
@@ -543,3 +565,39 @@ def find_s1s2(df:pd.DataFrame):
     
     return feature_array
 
+# ANALYZE
+
+def compute_segment_metrics(beattimes: pd.DataFrame, sr: int, audio: np.ndarray):
+   
+    beattimes[beattimes['Label (S1=1/S2=0)'] == 1]
+
+    segment_metrics = iterate_beat_segments(beattimes, sr, audio)
+
+    return segment_metrics
+
+def compute_and_plot_hrv(s1_to_s2, s2_to_s1, sampling_rate=1000):
+    # Combine s1_to_s2 and s2_to_s1 to get RR intervals
+    rr_intervals = np.array(s1_to_s2) + np.array(s2_to_s1)
+    
+    # Calculate cumulative time for each heartbeat
+    time = np.cumsum(rr_intervals) / sampling_rate  # Convert to seconds
+    
+    # Calculate instantaneous heart rate
+    hr = 60 / rr_intervals  # beats per minute
+    
+    # Compute rolling window HRV metrics
+    window_size = 30  # 30-second window
+    sdnn = np.array([np.std(rr_intervals[max(0, i-window_size):i+1]) 
+                     for i in range(len(rr_intervals))])
+    rmssd = np.array([np.sqrt(np.mean(np.diff(rr_intervals[max(0, i-window_size):i+1])**2)) 
+                      for i in range(len(rr_intervals))])
+    
+    # Create evenly spaced time array for plotting
+    t_interp = np.linspace(time.min(), time.max(), num=1000)
+    
+    # Interpolate HRV metrics for smooth plotting
+    sdnn_interp = interp1d(time, sdnn, kind='cubic')(t_interp)
+    rmssd_interp = interp1d(time, rmssd, kind='cubic')(t_interp)
+    hr_interp = interp1d(time, hr, kind='cubic')(t_interp)
+
+    return t_interp, sdnn_interp, rmssd_interp, hr_interp