Update app.py

app.py

@@ -4,140 +4,78 @@ import librosa
 import librosa.display
 import numpy as np
 import matplotlib.pyplot as plt
-import time
 
-# Load the pre-trained model (optional for this logic, depending on use case)
+# Load the pre-trained model
 model = tf.keras.models.load_model("model.h5")
 
 # Function to process audio, predict, and generate results
-def process_audio(audio_file, inhale_duration, exhale_duration):
+def process_audio(audio_file):
     try:
         # Load the audio file
         y, sr = librosa.load(audio_file, sr=16000)
         
-        # Compute energy (absolute value of the signal)
-        energy = np.abs(y)
+        # Detect segments (e.g., using energy or silence)
+        intervals = librosa.effects.split(y, top_db=20)
+        
+        results = []
+        highlighted_waveform = []
         
-        # Define a threshold for distinguishing inhalation from exhalation
-        threshold = 0.02  # This threshold can be adjusted based on your data
-
-        # Segment the audio based on energy
-        segments = librosa.effects.split(y, top_db=20)
-
-        all_segments = []  # To store all segments for table generation
-        prev_end = 0  # To track the previous segment's end time
-        prev_label = None  # To track the last segment label (Inhale/Exhale)
-        prev_start = 0  # To track the previous segment's start time
-
         plt.figure(figsize=(10, 4))
         librosa.display.waveshow(y, sr=sr, alpha=0.5)
-
-        # Loop through all segments and classify them
-        for i, (start, end) in enumerate(segments):
+        
+        # Process each segment
+        for i, (start, end) in enumerate(intervals):
             segment = y[start:end]
             duration = (end - start) / sr
-            mean_amplitude = np.mean(np.abs(segment))
-
-            # Classify the segment as Inhale or Exhale based on amplitude
-            label = "Exhale" if mean_amplitude > threshold else "Inhale"
-
-            # Store the first segment
-            if prev_end == 0:
-                prev_end = end
-                prev_start = start
-                prev_label = label
-                continue
-
-            # Calculate the duration between this segment and the previous one
-            segment_duration = (start - prev_end) / sr
-
-            # Append previous segment (Inhale or Exhale) to the list
-            all_segments.append({
-                "Segment": len(all_segments) + 1,
-                "Type": prev_label,
-                "Duration (s)": round(segment_duration, 2),
-                "Mean Amplitude": round(np.mean(np.abs(y[prev_start:prev_end])), 4),
-                "Start (s)": round(prev_start / sr, 2),
-                "End (s)": round(prev_end / sr, 2)
-            })
-
-            # Append current segment (Inhale or Exhale)
-            all_segments.append({
-                "Segment": len(all_segments) + 1,
+            
+            # Extract MFCC features
+            mfcc = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=13)
+            mfcc = np.mean(mfcc, axis=1).reshape(1, -1)
+            
+            # Predict inhale or exhale
+            prediction = model.predict(mfcc)
+            label = "Inhale" if np.argmax(prediction) == 0 else "Exhale"
+            
+            # Append results
+            results.append({
+                "Segment": i + 1,
                 "Type": label,
-                "Duration (s)": round(duration, 2),
-                "Mean Amplitude": round(mean_amplitude, 4),
-                "Start (s)": round(start / sr, 2),
-                "End (s)": round(end / sr, 2)
+                "Duration (s)": round(duration, 2)
             })
-
-            # Highlight the exhale periods in red
-            if label == "Exhale":
-                plt.axvspan(start / sr, end / sr, color='red', alpha=0.3)
-            # Highlight the inhale periods in blue
-            elif label == "Inhale":
-                plt.axvspan(prev_end / sr, start / sr, color='blue', alpha=0.3)
-
-            prev_start = start  # Update the start for the next iteration
-            prev_end = end  # Update the end for the next iteration
-            prev_label = label  # Update the label for the next iteration
-
+            
+            # Highlight segment on waveform
+            plt.axvspan(start / sr, end / sr, color='blue' if label == "Inhale" else 'red', alpha=0.3)
+        
         # Save the waveform with highlighted segments
         plt.title("Audio Waveform with Inhale/Exhale Segments")
         plt.xlabel("Time (s)")
         plt.ylabel("Amplitude")
         plt.savefig("waveform_highlighted.png")
         plt.close()
-
+        
         # Format results as a table
-        result_table = "Segment\tType\tDuration (s)\tMean Amplitude\tStart (s)\tEnd (s)\n" + "\n".join(
-            f"{row['Segment']}\t{row['Type']}\t{row['Duration (s)']}\t{row['Mean Amplitude']}\t{row['Start (s)']}\t{row['End (s)']}" for row in all_segments
+        result_table = "Segment\tType\tDuration (s)\n" + "\n".join(
+            f"{row['Segment']}\t{row['Type']}\t{row['Duration (s)']}" for row in results
         )
-
-        # Start countdown for recording
-        total_duration = inhale_duration + exhale_duration
-        countdown_message = f"Starting recording with total duration of {total_duration} seconds.\n"
-        countdown_message += f"Starting Inhale for {inhale_duration} seconds...\n"
-        
-        for t in range(inhale_duration, 0, -1):
-            time.sleep(1)
-            countdown_message += f"Inhale: {t}s remaining...\n"
-        
-        countdown_message += f"Switching to Exhale for {exhale_duration} seconds...\n"
         
-        for t in range(exhale_duration, 0, -1):
-            time.sleep(1)
-            countdown_message += f"Exhale: {t}s remaining...\n"
-        
-        countdown_message += "Recording Finished!"
-
-        return result_table, "waveform_highlighted.png", countdown_message
+        return result_table, "waveform_highlighted.png"
     
     except Exception as e:
-        return f"Error: {str(e)}", None, None
-
+        return f"Error: {str(e)}", None
 
 # Define Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("### Breathe Training Application")
-    
-    # Input fields for setting inhale and exhale duration
-    with gr.Row():
-        inhale_duration = gr.Number(label="Inhale Duration (s)", value=4, min_value=1)
-        exhale_duration = gr.Number(label="Exhale Duration (s)", value=4, min_value=1)
-        
     with gr.Row():
         audio_input = gr.Audio(type="filepath", label="Upload or Record Audio")
         result_output = gr.Textbox(label="Prediction Results (Table)")
         waveform_output = gr.Image(label="Waveform with Highlighted Segments")
-        countdown_output = gr.Textbox(label="Countdown Timer")
-
-    submit_button = gr.Button("Start Record")
+    submit_button = gr.Button("Analyze")
     
     submit_button.click(
         fn=process_audio,
-        inputs=[audio_input, inhale_duration, exhale_duration],
-        outputs=[result_output, waveform_output, countdown_output]
+        inputs=[audio_input],
+        outputs=[result_output, waveform_output]
     )
 
 # Run the Gradio app