new v2

app.py

@@ -1,6 +1,7 @@
 from plotly.subplots import make_subplots
 from scipy.signal import find_peaks, butter, filtfilt
 import plotly.graph_objects as go
+import pandas as pd
 import gradio as gr
 import numpy as np
 import itertools
@@ -8,55 +9,14 @@ import librosa
 import random
 import os
 
+from utils import getaudiodata, getBeats, plotBeattimes
+
 example_dir = "Examples"
 example_files = [os.path.join(example_dir, f) for f in os.listdir(example_dir) if f.endswith(('.wav', '.mp3', '.ogg'))]
 all_pairs = list(itertools.combinations(example_files, 2))
 random.shuffle(all_pairs)
 example_pairs = [list(pair) for pair in all_pairs[:25]]
 
-# GENERAL HELPER FUNCTIONS
-def getaudiodata(filepath)->tuple[int,np.ndarray]:
-
-    audiodata, sr = librosa.load(filepath, sr=None)
-
-    # Ensure audiodata is a numpy array
-    if not isinstance(audiodata, np.ndarray):
-        audiodata = np.array(audiodata)
-
-    # Check if audio is mono or stereo
-    if len(audiodata.shape) > 1:
-        # If stereo, convert to mono by averaging channels
-        audiodata = np.mean(audiodata, axis=1)
-
-    audiodata = np.astype(audiodata, np.float16)
-
-    return sr, audiodata
-
-def getBeats(audiodata:np.ndarray, sr:int):
-    # Convert audio data to float32
-    audiodata = audiodata.astype(np.float32)
-    
-    # Normalize the audio data
-    audiodata = audiodata / np.max(np.abs(audiodata))
-    
-    # Set the threshold for peak detection (adjust this value as needed)
-    threshold = 0.5  # 50% of the maximum amplitude
-    
-    # Find peaks above the threshold
-    peaks, _ = find_peaks(np.abs(audiodata), height=threshold, distance=int(sr * 0.3))
-    
-    # Convert peak indices to times
-    peak_times = (peaks / sr)*2
-    
-    # Calculate tempo (beats per minute)
-    if len(peak_times) > 1:
-        avg_interval = np.mean(np.diff(peak_times))
-        tempo = 60 / avg_interval
-    else:
-        tempo = 0
-    
-    return [tempo], peak_times
-
 def getHRV(beattimes: np.ndarray) -> np.ndarray:
     # Calculate instantaneous heart rate
     instantaneous_hr = 60 * np.diff(beattimes)
@@ -166,43 +126,6 @@ def plotCombined(audiodata, sr, filename):
     
     return fig
 
-def plotbeatscatter(tempo, beattimes):
-    # Calculate beat durations
-    beat_durations = np.diff(beattimes)
-
-    # Calculate cumulative times for x-axis
-    cumulative_times = np.cumsum(beat_durations)
-
-    # Create scatter plot
-    fig = go.Figure()
-
-    # Add scatter plot of beat durations
-    fig.add_trace(go.Scatter(
-        x=cumulative_times,
-        y=beat_durations,
-        mode='markers',
-        name='Beat Durations',
-        marker=dict(
-            size=8
-        )
-    ))
-
-    # Add line for average beat duration
-    avg_duration = 60 / tempo[0] if isinstance(tempo, list) else 60 / tempo  # Convert tempo (BPM) to seconds
-    fig.add_hline(y=avg_duration, line=dict(color='red', dash='dash'),
-                  annotation_text=f"Average: {avg_duration:.2f}s",
-                  annotation_position="top right")
-
-    # Update layout
-    fig.update_layout(
-        title_text='Beat Durations Over Time',
-        xaxis_title_text='Cumulative Time (seconds)',
-        yaxis_title_text='Beat Duration (seconds)',
-        showlegend=True
-    )
-
-    return fig
-
 def analyze_single(audio:gr.Audio):
     # Extract audio data and sample rate
     filepath = audio
@@ -230,7 +153,7 @@ def analyze_single(audio:gr.Audio):
 
     tempo, beattimes = getBeats(audiodata, sr)
     spectogram_wave = plotCombined(audiodata, sr, filename)
-    beats_histogram = plotbeatscatter(tempo[0], beattimes)
+    #beats_histogram = plotbeatscatter(tempo[0], beattimes)
 
     # Add the new average heartbeat analysis
     avg_beat_plot, avg_beat = create_average_heartbeat(audiodata, sr)
@@ -253,83 +176,28 @@ def analyze_single(audio:gr.Audio):
     - Beat durations: {np.diff(beattimes)}
     - Mean Beat Duration: {np.mean(np.diff(beattimes)):.4f}
     """
-    return results, spectogram_wave, avg_beat_plot, beats_histogram
+    return results, spectogram_wave, avg_beat_plot
 #-----------------------------------------------
 #-----------------------------------------------
 
-# HELPER FUNCTIONS FOR DUAL AUDIO ANALYSIS
-def analyze_double(audio1:gr.Audio, audio2:gr.Audio):
-    
-    sr1, audiodata1 = getaudiodata(audio1)
-    sr2, audiodata2 = getaudiodata(audio2)
+# HELPER FUNCTIONS FOR SINGLE AUDIO ANALYSIS V2
 
+def getBeatsv2(audio:gr.Audio):
 
-    combinedfig = plotCombineddouble(audiodata1, sr1, audiodata2, sr2)
-    return combinedfig
+    sr, audiodata = getaudiodata(audio)
+    _, beattimes = getBeats(audiodata, sr)
 
-def plotCombineddouble(audiodata1, sr1, audiodata2, sr2):
-    # Create subplots
-    fig = make_subplots(rows=2, cols=2, shared_xaxes=True, vertical_spacing=0.1, shared_yaxes=True,
-                        subplot_titles=['Audio 1 Waveform','Audio 2 Audio Waveform', 'Audio 1 Spectrogram', 'Audio 2 Spectrogram'])
+    fig = plotBeattimes(beattimes, audiodata, sr)
+    beattimes_table = pd.DataFrame(data={"Beattimes":beattimes})
 
-    # Waveform plot
-    time = (np.arange(0, len(audiodata1)) / sr1)*2
-    fig.add_trace(
-        go.Scatter(x=time, y=audiodata1, mode='lines', line=dict(color='blue', width=1), showlegend=False),
-        row=1, col=1
-    )
+    return fig, beattimes_table
 
-    # Spectrogram plot
-    D = librosa.stft(audiodata1)
-    S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)
-    times = librosa.times_like(S_db)
-    freqs = librosa.fft_frequencies(sr=sr1)
+def updateBeatsv2(beattimes_table:gr.Dataframe, audio:gr.Audio)-> go.Figure:
+    sr, audiodata = getaudiodata(audio)
+    return plotBeattimes(beattimes_table["Beattimes"], audiodata, sr)
 
-    fig.add_trace(
-        go.Heatmap(z=S_db, x=times, y=freqs, colorscale='Viridis', 
-                   zmin=S_db.min(), zmax=S_db.max(), showlegend=False),#, colorbar=dict(title='Magnitude (dB)')),
-        row=2, col=1
-    )
 
-    # Waveform plot
-    time = (np.arange(0, len(audiodata2)) / sr2)*2
-    fig.add_trace(
-        go.Scatter(x=time, y=audiodata2, mode='lines', line=dict(color='blue', width=1), showlegend=False),
-        row=1, col=2
-    )
 
-    # Spectrogram plot
-    D = librosa.stft(audiodata2)
-    S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)
-    times = librosa.times_like(S_db)
-    freqs = librosa.fft_frequencies(sr=sr2)
-
-    fig.add_trace(
-        go.Heatmap(z=S_db, x=times, y=freqs, colorscale='Viridis', 
-                   zmin=S_db.min(), zmax=S_db.max(), showlegend=False),#, colorbar=dict(title='Magnitude (dB)')),
-        row=2, col=2
-    )
-
-
-
-
-
-    # Update layout
-    fig.update_layout(
-        height=800, width=1200,
-        title_text="Audio Analysis",
-        showlegend=False
-    )
-
-    fig.update_xaxes(title_text="Time (s)", row=2, col=1)
-    fig.update_yaxes(title_text="Amplitude", row=1, col=1)
-    fig.update_yaxes(title_text="Frequency (Hz)", type="log", row=2, col=1)
-
-    fig.update_xaxes(title_text="Time (s)", row=2, col=2)
-    fig.update_yaxes(title_text="Amplitude", row=1, col=2)
-    fig.update_yaxes(title_text="Frequency (Hz)", type="log", row=2, col=2)
-
-    return fig
 
 
 
@@ -337,7 +205,7 @@ def plotCombineddouble(audiodata1, sr1, audiodata2, sr2):
 with gr.Blocks() as app:
 
     gr.Markdown("# Heartbeat")
-    gr.Markdown("This App helps to analyze and extract Information from Heartbeats")
+    gr.Markdown("This App helps to analyze and extract Information from Heartbeat Audios")
     gr.Markdown("""
     - Beat (mean) (average heartbeat duration)
     - S1, S2 (mean) (average S1,S2 duration)
@@ -346,21 +214,46 @@ with gr.Blocks() as app:
     - Plot of Wave & Spectogram (Beats annotated)
     """)
 
-    with gr.Tab("Single Audio"):
+    audiofile = gr.Audio(
+                type="filepath",
+                label="Upload the Audio of a Heartbeat",
+                sources="upload")
 
-        audiofile = gr.Audio(
-            type="filepath",
-            label="Audio of a Heartbeat",
-            sources="upload")
+
+    with gr.Tab("Single Audio V2"):
+        
+        getBeatsbtn = gr.Button("get Beats")
+
+        beats_wave_plot = gr.Plot()
+        beattimes_table = gr.Dataframe(
+            col_count=1,
+            type='pandas',
+            interactive=True)
         
+        updateBeatsbtn = gr.Button("update Beats")
+
+
+
+        getBeatsbtn.click(getBeatsv2, inputs=audiofile, outputs=[beats_wave_plot, beattimes_table])
+        updateBeatsbtn.click(updateBeatsv2, inputs=[beattimes_table, audiofile], outputs=[beats_wave_plot])
+
+        gr.Examples(
+            examples=example_files,
+            inputs=audiofile,
+            fn=getBeatsv2,
+            cache_examples=False
+        )
+
+
+    with gr.Tab("Single Audio V1"):
+
         analyzebtn = gr.Button("analyze")
 
         results = gr.Markdown()
         spectogram_wave = gr.Plot()
         avg_beat_plot = gr.Plot()
-        beats_histogram = gr.Plot()
 
-        analyzebtn.click(analyze_single, audiofile, [results, spectogram_wave, avg_beat_plot, beats_histogram])
+        analyzebtn.click(analyze_single, audiofile, [results, spectogram_wave, avg_beat_plot])
 
         gr.Examples(
             examples=example_files,
@@ -371,34 +264,6 @@ with gr.Blocks() as app:
         )
 
 
-    # with gr.Tab("Two Audios"):
-
-    #     with gr.Row():
-
-    #         audioone = gr.Audio(
-    #             type="filepath",
-    #             label="Audio of a Heartbeat",
-    #             sources="upload")
-    #         audiotwo = gr.Audio(
-    #             type="filepath",
-    #             label="Audio of a Heartbeat",
-    #             sources="upload")
-            
-    #     analyzebtn2 = gr.Button("analyze & compare")
-
-    #     with gr.Accordion("Results",open=False):
-    #         results2 = gr.Markdown()
-    #         spectogram_wave2 = gr.Plot()
-
-    #     analyzebtn2.click(analyze_double, inputs=[audioone,audiotwo], outputs=spectogram_wave2)
-
-    #     gr.Examples(
-    #         examples=example_pairs,
-    #         inputs=[audioone, audiotwo],
-    #         outputs=spectogram_wave2,
-    #         fn=analyze_double,
-    #         cache_examples=False
-    #     )
 
 
 app.launch()

utils.py

@@ -0,0 +1,141 @@
+import librosa
+import numpy as np
+import plotly.graph_objects as go
+from scipy.signal import find_peaks
+
+
+# GENERAL HELPER FUNCTIONS
+def getaudiodata(filepath)->tuple[int,np.ndarray]:
+
+    audiodata, sr = librosa.load(filepath, sr=None)
+
+    # Ensure audiodata is a numpy array
+    if not isinstance(audiodata, np.ndarray):
+        audiodata = np.array(audiodata)
+
+    # Check if audio is mono or stereo
+    if len(audiodata.shape) > 1:
+        # If stereo, convert to mono by averaging channels
+        audiodata = np.mean(audiodata, axis=1)
+
+    audiodata = np.astype(audiodata, np.float16)
+
+    return sr, audiodata
+
+def getBeats(audiodata:np.ndarray, sr:int):
+    # Convert audio data to float32
+    audiodata = audiodata.astype(np.float32)
+    
+    # Normalize the audio data
+    audiodata = audiodata / np.max(np.abs(audiodata))
+    
+    # Set the threshold for peak detection (adjust this value as needed)
+    threshold = 0.5  # 50% of the maximum amplitude
+    
+    # Find peaks above the threshold
+    peaks, _ = find_peaks(np.abs(audiodata), height=threshold, distance=int(sr * 0.3))
+    
+    # Convert peak indices to times
+    peak_times = (peaks / sr)*2
+    
+    # Calculate tempo (beats per minute)
+    if len(peak_times) > 1:
+        avg_interval = np.mean(np.diff(peak_times))
+        tempo = 60 / avg_interval
+    else:
+        tempo = 0
+    
+    return [tempo], peak_times
+
+def plotBeattimes(beattimes:np.ndarray, audiodata:np.ndarray, sr:int)->go.Figure:
+
+        # Time array for the full audio
+    time = (np.arange(0, len(audiodata)) / sr) * 2
+
+    # CREATE BEATTIMES PLOT    
+    # Waveform plot
+    fig = go.Figure(
+        go.Scatter(x=time, y=audiodata, mode='lines', name='Waveform', line=dict(color='blue', width=1))
+    )
+    # Add beat markers
+    beat_amplitudes = np.interp(beattimes, time, audiodata)
+    fig.add_trace(
+        go.Scatter(x=beattimes, y=beat_amplitudes, mode='markers', name='Beats',
+                   marker=dict(color='red', size=8, symbol='circle'))
+    )
+
+    fig.update_layout(
+        showlegend=False
+    )
+
+    return fig
+
+
+def iterate_beat_segments(beat_times, sr, audio):
+    """
+    Iterate over audio segments between beats.
+    
+    Parameters:
+    - beat_times: np.ndarray of beat times in seconds
+    - sr: Sample rate of the audio
+    - audio: np.ndarray of audio data
+    
+    Yields:
+    - Tuple of (start_sample, end_sample, audio_segment)
+    """
+    # 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)]))
+    
+    # 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]
+
+        segment_metrics = segment_analysis(segment, sr)
+
+
+
+def segment_analysis(segment, sr):
+    """
+    Analyze an audio segment and compute various metrics.
+    
+    Parameters:
+    - segment: np.ndarray of audio segment data
+    - sr: Sample rate of the audio
+    
+    Returns:
+    - List of computed metrics
+    """
+    # Duration
+    duration = len(segment) / sr
+    
+    # RMS Energy
+    rms_energy = np.sqrt(np.mean(segment**2))
+    
+    # Frequencies
+    # We'll use the mean of the magnitudes of the Fourier transform
+    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
+    
+    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
+    ]