update app.py with circle

app.py

@@ -4,43 +4,43 @@ import librosa
 import librosa.display
 import numpy as np
 import matplotlib.pyplot as plt
+import sounddevice as sd
+import soundfile as sf
+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):
+def process_audio(audio_file, breath_in_time, breath_out_time):
     try:
         # Load the audio file
         y, sr = librosa.load(audio_file, sr=16000)
-        
+
         # Detect segments (e.g., using energy or silence)
         intervals = librosa.effects.split(y, top_db=20)
-        
+
         results = []
-        
+
         plt.figure(figsize=(10, 4))
         librosa.display.waveshow(y, sr=sr, alpha=0.5)
-        
+
         # Process each segment
         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
             mfcc = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=13)
             mfcc = np.mean(mfcc, axis=1).reshape(1, -1)
-            
-            # Predict inhale or exhale (override with amplitude logic)
+
+            # Predict inhale or exhale
             prediction = model.predict(mfcc)
-            label_from_model = "Inhale" if np.argmax(prediction) == 0 else "Exhale"
-            
-            # Assign label based on amplitude
-            label = "Inhale" if amplitude > 0.05 else "Exhale"  # Threshold for exhale
-            
+            label = "Inhale" if np.argmax(prediction) == 0 else "Exhale"
+
             # Append results
             results.append({
                 "Segment": i + 1,
@@ -48,41 +48,113 @@ def process_audio(audio_file):
                 "Duration (s)": round(duration, 2),
                 "Amplitude": round(amplitude, 4)
             })
-            
-            # Highlight segment on waveform with swapped colors
+
+            # 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
         )
-        
+
         return result_table, "waveform_highlighted.png"
-    
+
     except Exception as e:
         return f"Error: {str(e)}", None
 
-# Define Gradio interface
+# 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>
+    """)
+
+    # File upload and analysis
     with gr.Row():
-        audio_input = gr.Audio(type="filepath", label="Upload or Record Audio")
+        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")
-    submit_button = gr.Button("Analyze")
-    
-    submit_button.click(
-        fn=process_audio,
-        inputs=[audio_input],
-        outputs=[result_output, waveform_output]
+
+    # Handle recording and analysis
+    record_button.click(
+        fn=lambda breath_in, breath_out: process_audio(record_audio(breath_in + breath_out), breath_in, breath_out),
+        inputs=[breath_in_time, breath_out_time],
+        outputs=[result_output, waveform_output],
     )
 
 # Run the Gradio app
-demo.launch() 
+demo.launch()