Update app.py

app.py

@@ -1,7 +1,6 @@
 import gradio as gr
 import tensorflow as tf
 import librosa
-import librosa.display
 import numpy as np
 import matplotlib.pyplot as plt
 import sounddevice as sd
@@ -11,17 +10,19 @@ import threading
 # 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, breath_in_time, breath_out_time):
     try:
+        # Calculate total recording duration
+        total_time = breath_in_time + breath_out_time
+
         # Load the audio file
         y, sr = librosa.load(audio_file, sr=16000)
 
-        # Detect segments (e.g., using energy or silence)
+        # Detect segments
         intervals = librosa.effects.split(y, top_db=20)
 
         results = []
-
         plt.figure(figsize=(10, 4))
         librosa.display.waveshow(y, sr=sr, alpha=0.5)
 
@@ -29,8 +30,6 @@ def process_audio(audio_file, breath_in_time, breath_out_time):
         for i, (start, end) in enumerate(intervals):
             segment = y[start:end]
             duration = (end - start) / sr
-
-            # Compute the amplitude (mean absolute value)
             amplitude = np.mean(np.abs(segment))
 
             # Extract MFCC features
@@ -39,9 +38,10 @@ def process_audio(audio_file, breath_in_time, breath_out_time):
 
             # Predict inhale or exhale
             prediction = model.predict(mfcc)
-            label = "Inhale" if np.argmax(prediction) == 0 else "Exhale"
+            label_from_model = "Inhale" if np.argmax(prediction) == 0 else "Exhale"
+
+            label = "Inhale" if amplitude > 0.05 else "Exhale"
 
-            # Append results
             results.append({
                 "Segment": i + 1,
                 "Type": label,
@@ -49,17 +49,14 @@ def process_audio(audio_file, breath_in_time, breath_out_time):
                 "Amplitude": round(amplitude, 4)
             })
 
-            # Highlight segment on waveform
             plt.axvspan(start / sr, end / sr, color='red' if label == "Inhale" else 'blue', 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)\tAmplitude\n" + "\n".join(
             f"{row['Segment']}\t{row['Type']}\t{row['Duration (s)']}\t{row['Amplitude']}" for row in results
         )
@@ -69,92 +66,77 @@ def process_audio(audio_file, breath_in_time, breath_out_time):
     except Exception as e:
         return f"Error: {str(e)}", None
 
-# Function to record audio for a specified duration
+
 def record_audio(duration):
     try:
         audio_file = "recorded_audio.wav"
-        print(f"Recording for {duration} seconds...")
         recording = sd.rec(int(duration * 16000), samplerate=16000, channels=1, dtype='float32')
         sd.wait()
         sf.write(audio_file, recording, 16000)
-        print("Recording complete!")
         return audio_file
     except Exception as e:
         return f"Error: {str(e)}"
 
-# Gradio Interface
+
 with gr.Blocks() as demo:
     gr.Markdown("### Breathe Training Application")
 
-    # Breath cycle configuration
     with gr.Row():
-        breath_in_time = gr.Number(label="Breathe In Time (seconds)", value=3, interactive=True)
-        breath_out_time = gr.Number(label="Breathe Out Time (seconds)", value=3, interactive=True)
-
-    # Circle Animation using Custom HTML and CSS
-    gr.HTML("""
-    <div style="text-align: center;">
-        <div id="circle" style="
-            width: 100px;
-            height: 100px;
-            border-radius: 50%;
-            background-color: lightblue;
-            margin: 20px auto;
-            animation: breathe 6s infinite;">
-        </div>
-        <p id="instruction" style="font-size: 20px; font-weight: bold;">Breathe In...</p>
-    </div>
-    <style>
-        @keyframes breathe {
-            0% { transform: scale(1); }
-            50% { transform: scale(1.5); }
-            100% { transform: scale(1); }
-        }
-    </style>
-    <script>
-        const instruction = document.getElementById("instruction");
-        let breatheInTime = 3;  // Default value for inhale
-        let breatheOutTime = 3; // Default value for exhale
-
-        function updateBreathingCycle(inTime, outTime) {
-            breatheInTime = inTime;
-            breatheOutTime = outTime;
-            const totalTime = inTime + outTime;
-            const keyframes = `
-                @keyframes breathe {
-                    0% { transform: scale(1); }
-                    ${Math.round((inTime / totalTime) * 100)}% { transform: scale(1.5); }
-                    100% { transform: scale(1); }
-                }
-            `;
-            const styleSheet = document.styleSheets[0];
-            styleSheet.insertRule(keyframes, styleSheet.cssRules.length);
-
-            let isInhaling = true;
-            setInterval(() => {
-                instruction.textContent = isInhaling ? "Breathe In..." : "Breathe Out...";
-                isInhaling = !isInhaling;
-            }, inTime * 1000);
-        }
-
-        // Default breathing cycle
-        updateBreathingCycle(breatheInTime, breatheOutTime);
-    </script>
-    """)
+        breath_in_time = gr.Number(label="Breath In Time (seconds)", value=3, interactive=True)
+        breath_out_time = gr.Number(label="Breath Out Time (seconds)", value=3, interactive=True)
 
-    # File upload and analysis
     with gr.Row():
         record_button = gr.Button("Start Recording")
         audio_input = gr.Audio(type="filepath", label="Upload Audio (optional)")
         result_output = gr.Textbox(label="Prediction Results (Table)")
         waveform_output = gr.Image(label="Waveform with Highlighted Segments")
 
-    # Handle recording and analysis
+    with gr.HTML(value="""
+        <div style="display: flex; justify-content: center; align-items: center; height: 300px;">
+            <div id="circle" style="width: 50px; height: 50px; background-color: lightblue; border-radius: 50%;"></div>
+        </div>
+        <script>
+            let interval;
+            function scaleCircle(breathIn, breathOut, duration) {
+                const circle = document.getElementById('circle');
+                let scaleUp = true;
+                const breathInTime = breathIn * 1000;
+                const breathOutTime = breathOut * 1000;
+
+                if (interval) clearInterval(interval);
+
+                interval = setInterval(() => {
+                    if (scaleUp) {
+                        circle.style.transition = `transform ${breathInTime}ms linear`;
+                        circle.style.transform = "scale(3)";
+                    } else {
+                        circle.style.transition = `transform ${breathOutTime}ms linear`;
+                        circle.style.transform = "scale(1)";
+                    }
+                    scaleUp = !scaleUp;
+                }, duration * 1000);
+            }
+
+            function stopCircleAnimation() {
+                const circle = document.getElementById('circle');
+                clearInterval(interval);
+                circle.style.transform = "scale(1)";
+                circle.style.transition = "none";
+            }
+        </script>
+    """)
+
+    def handle_record_and_visualize(breath_in, breath_out):
+        total_duration = breath_in + breath_out
+        threading.Timer(total_duration, lambda: gr.run_js("stopCircleAnimation()")).start()
+        gr.run_js(f"scaleCircle({breath_in}, {breath_out}, {total_duration});")
+        audio_file = record_audio(total_duration)
+        return process_audio(audio_file, breath_in, breath_out)
+
     record_button.click(
-        fn=lambda breath_in, breath_out: process_audio(record_audio(breath_in + breath_out), breath_in, breath_out),
+        fn=handle_record_and_visualize,
         inputs=[breath_in_time, breath_out_time],
         outputs=[result_output, waveform_output],
     )
 
-# Run the Gradio app
 demo.launch()