Update app.py

app.py

@@ -51,7 +51,7 @@ try:
 except Exception as e:
     print(f"Error loading models or scaler: {e}")
 
-def predict_and_plot(velocity, temperature, precipitation, humidity):
+def predict_contamination_gradients(velocity, temperature, precipitation, humidity):
     try:
         # Prepare the example data
         example_data = pd.DataFrame({
@@ -83,64 +83,45 @@ def predict_and_plot(velocity, temperature, precipitation, humidity):
         # Predict contamination levels and gradients for the single example
         contamination_levels, gradients = predict_contamination_and_gradients(example_data_scaled)
 
+        return contamination_levels[0], gradients[0]
+
+    except Exception as e:
+        print(f"Error in Gradio interface: {e}")
+        return ["Error"] * 12
+
+def plot_contamination_over_time(velocity, temperature, precipitation, humidity):
+    try:
+        # Predict contamination levels first
+        contamination_levels, _ = predict_contamination_gradients(velocity, temperature, precipitation, humidity)
+
         # Simulate contamination levels at multiple time intervals
         time_intervals = np.arange(0, 601, 60)  # Simulating time intervals from 0 to 600 seconds
 
         # Generate simulated contamination levels (linear interpolation between predicted values)
         simulated_contamination_levels = np.array([
-            np.linspace(contamination_levels[0][i], contamination_levels[0][i] * 2, len(time_intervals))
-            for i in range(contamination_levels.shape[1])
+            np.linspace(contamination_levels[i], contamination_levels[i] * 2, len(time_intervals))
+            for i in range(len(contamination_levels))
         ]).T
 
-        # Function to calculate cleaning time using linear interpolation
-        def calculate_cleaning_time(time_intervals, contamination_levels, threshold=0.4):
-            cleaning_times = []
-            for i in range(contamination_levels.shape[1]):
-                levels = contamination_levels[:, i]
-                for j in range(1, len(levels)):
-                    if levels[j-1] <= threshold <= levels[j]:
-                        # Linear interpolation
-                        t1, t2 = time_intervals[j-1], time_intervals[j]
-                        c1, c2 = levels[j-1], levels[j]
-                        cleaning_time = t1 + (threshold - c1) * (t2 - t1) / (c2 - c1)
-                        cleaning_times.append(cleaning_time)
-                        break
-                else:
-                    cleaning_times.append(time_intervals[-1])  # If threshold is not reached
-            return cleaning_times
-
-        # Calculate cleaning times for all 6 lidars
-        cleaning_times = calculate_cleaning_time(time_intervals, simulated_contamination_levels)
-
-        # Lidar names
-        lidar_names = ['F/L', 'F/R', 'Left', 'Right', 'Roof', 'Rear']
-
         # Plot the graph
         fig, ax = plt.subplots(figsize=(12, 8))
 
+        lidar_names = ['F/L', 'F/R', 'Left', 'Right', 'Roof', 'Rear']
         for i in range(simulated_contamination_levels.shape[1]):
             ax.plot(time_intervals, simulated_contamination_levels[:, i], label=f'{lidar_names[i]}')
             ax.axhline(y=0.4, color='r', linestyle='--', label='Contamination Threshold' if i == 0 else "")
-            if i < len(cleaning_times):
-                ax.scatter(cleaning_times[i], 0.4, color='k')  # Mark the cleaning time point
 
         ax.set_title('Contamination Levels Over Time for Each Lidar')
         ax.set_xlabel('Time (seconds)')
         ax.set_ylabel('Contamination Level')
         ax.legend()
         ax.grid(True)
-        
-        # Flatten the results into a single list of 19 outputs (1 plot + 6 contamination + 6 gradients + 6 cleaning times)
-        plot_output = fig
-        contamination_output = [f"{val * 100:.2f}%" for val in contamination_levels[0]]
-        gradients_output = [f"{val:.4f}" for val in gradients[0]]
-        cleaning_time_output = [f"{val:.2f}" for val in cleaning_times]
 
-        return [plot_output] + contamination_output + gradients_output + cleaning_time_output
+        return fig
 
     except Exception as e:
-        print(f"Error in Gradio interface: {e}")
-        return [plt.figure()] + ["Error"] * 18
+        print(f"Error in plotting: {e}")
+        return plt.figure()
 
 inputs = [
     gr.Slider(minimum=0, maximum=100, value=50, step=0.05, label="Velocity (mph)"),
@@ -189,9 +170,9 @@ with gr.Blocks() as demo:
             # Submit and Clear Buttons under the inputs
             with gr.Row():
                 gr.Button(value="Submit", variant="primary").click(
-                    fn=predict_and_plot, 
+                    fn=predict_contamination_gradients, 
                     inputs=inputs, 
-                    outputs=[gr.Plot(label="Contamination Levels Over Time")] + contamination_outputs + gradients_outputs + cleaning_time_outputs
+                    outputs=contamination_outputs + gradients_outputs + cleaning_time_outputs
                 )
                 gr.Button(value="Clear").click(fn=lambda: None)
 
@@ -219,6 +200,10 @@ with gr.Blocks() as demo:
     with gr.Row():
         with gr.Column():
             gr.Markdown("### Contamination Levels Over Time")
-            gr.Plot(label="Contamination Levels Over Time")
+            gr.Plot(label="Contamination Levels Over Time").click(
+                fn=plot_contamination_over_time, 
+                inputs=inputs, 
+                outputs="plot"
+            )
 
 demo.launch()