Om realtime Seaborn-visualisaties te maken die automatisch worden bijgewerkt bij binnenkomst van nieuwe data, kun je de volgende aanpak volgen: 1. Data ophalen: - Gebruik een HTTP- of WebSocket-verbinding om elke 10 seconden nieuwe gegevens te verkrijgen van de bron wss://voorbeeld.com/stream. - Verwerk de JSON-gegevens zodat je een pandas DataFrame krijgt met kolommen: tijdstempel, sensor_id, waarde. 2. Visualisatie opzetten: - Aangezien Seaborn niet direct geschikt is voor dynamische, interactieve plots, kun je overwegen om Matplotlib te gebruiken in combinatie met Seaborn voor styling. - Maak een lijnplot van de waarden over tijd, bijvoorbeeld per sensor_id. 3. Automatisch bijwerken: - Gebruik een loop met een tijdsinterval (bijvoorbeeld via `matplotlib.animation.FuncAnimation`) of een `while`-lus met `time.sleep(10)` om elke 10 seconden de data te refreshen. - Bij elke update: - Haal nieuwe data op. - Vernieuw de plot door de oude data te verwijderen of te updaten. 4. Interactiviteit en tooltips: - Matplotlib biedt beperkte ondersteuning voor interactieve tooltips. - Voor uitgebreide interactiviteit, zoals tooltips bij hover, kun je beter gebruik maken van Plotly of Bokeh. - Deze bibliotheken ondersteunen dynamische updates en interactieve hover-gegevens makkelijker dan Seaborn/Matplotlib. **Voorbeeld met Plotly (aanbevolen voor interactiviteit):** ```python import requests import pandas as pd import plotly.graph_objects as go import time # Functie om data op te halen def fetch_data(): response = requests.get("https://voorbeeld.com/stream") json_data = response.json() df = pd.DataFrame(json_data) # Zorg dat tijdstempel als datetime wordt geïnterpreteerd df['tijdstempel'] = pd.to_datetime(df['tijdstempel']) return df # Initieel ophalen van data df = fetch_data() # Maak initiële figuur fig = go.Figure() # Voeg traces toe per sensor sensors = df['sensor_id'].unique() for sensor in sensors: sensor_data = df[df['sensor_id'] == sensor] fig.add_trace(go.Scatter( x=sensor_data['tijdstempel'], y=sensor_data['waarde'], mode='lines', name=f'Sensor {sensor}', hoverinfo='x+y+name' )) # Instellingen fig.update_layout( title='Realtime sensor data', xaxis_title='Tijd', yaxis_title='Waarde' ) # Live update functie def update_plot(): global df, fig new_data = fetch_data() df = pd.concat([df, new_data]).drop_duplicates(subset=['tijdstempel', 'sensor_id']) # Filter op de laatste 10 minuten of een andere logica # Voor eenvoud, gebruik alle data fig.data = [] # Verwijder oude traces for sensor in df['sensor_id'].unique(): sensor_data = df[df['sensor_id'] == sensor] fig.add_trace(go.Scatter( x=sensor_data['tijdstempel'], y=sensor_data['waarde'], mode='lines', name=f'Sensor {sensor}', hoverinfo='x+y+name' )) fig.show() # Loop voor continue updates while True: update_plot() time.sleep(10) ``` **Samenvatting:** - Gebruik een bibliotheek die realtime en interactieve visualisaties ondersteunt, zoals Plotly of Bokeh. - Haal elke 10 seconden nieuwe data op via een API of WebSocket. - Update de visualisatie dynamisch door de grafiek te refreshen. - Voeg tooltips toe voor interactieve gegevensweergave bij hover. Voor een volledig werkend voorbeeld moet je je data- en verbindingslogica aanpassen aan je specifieke situatie.

Ik help je graag met het maken van realtime Seaborn-visualisaties. Hier is een complete oplossing in Python: ```python import json import websocket import threading import pandas as pd import seaborn as sns import matplotlib.pyplot as plt import matplotlib.animation as animation from matplotlib.widgets import Cursor from datetime import datetime import time # Stel Seaborn stijl in sns.set_style("whitegrid") plt.rcParams["figure.figsize"] = [12, 6] # Globale variabelen voor dataopslag data_buffer = [] last_update_time = 0 update_interval = 10 # seconden # Maak figure en axes fig, ax = plt.subplots() cursor = Cursor(ax, useblit=True, color='red', linewidth=1) # Functie om WebSocket berichten te verwerken def on_message(ws, message): global data_buffer, last_update_time try: # Parse JSON data data = json.loads(message) # Voeg timestamp toe als datetime object data['datetime'] = datetime.fromisoformat(data['tijdstempel'].replace('Z', '+00:00')) # Voeg toe aan buffer data_buffer.append(data) # Beperk buffer grootte (bijv. laatste 100 metingen) if len(data_buffer) > 100: data_buffer = data_buffer[-100:] except json.JSONDecodeError as e: print(f"JSON parse fout: {e}") except Exception as e: print(f"Fout bij verwerken bericht: {e}") # Functie om WebSocket errors af te handelen def on_error(ws, error): print(f"WebSocket error: {error}") def on_close(ws, close_status_code, close_msg): print("WebSocket verbinding gesloten") def on_open(ws): print("WebSocket verbinding geopend") # Animation update functie def update_plot(frame): global data_buffer, last_update_time current_time = time.time() # Alleen updaten elke 10 seconden if current_time - last_update_time >= update_interval and data_buffer: ax.clear() # Converteer naar DataFrame df = pd.DataFrame(data_buffer) if not df.empty: # Maak lijnplot met Seaborn sns.lineplot(data=df, x='datetime', y='waarde', hue='sensor_id', ax=ax, marker='o') # Styling ax.set_title('Realtime Sensor Data', fontsize=16, fontweight='bold') ax.set_xlabel('Tijdstempel', fontsize=12) ax.set_ylabel('Sensor Waarde', fontsize=12) ax.tick_params(axis='x', rotation=45) # Formatteer x-as labels ax.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%H:%M:%S')) # Voeg grid toe ax.grid(True, alpha=0.3) # Voeg legenda toe ax.legend(title='Sensor ID', bbox_to_anchor=(1.05, 1), loc='upper left') # Tooltip functionaliteit annot = ax.annotate("", xy=(0,0), xytext=(20,20), textcoords="offset points", bbox=dict(boxstyle="round", fc="w"), arrowprops=dict(arrowstyle="->")) annot.set_visible(False) def update_annot(ind, line): x, y = line.get_data() annot.xy = (x[ind["ind"][0]], y[ind["ind"][0]]) text = f"Tijd: {x[ind['ind'][0]]:%H:%M:%S}\nWaarde: {y[ind['ind'][0]]:.2f}" annot.set_text(text) annot.get_bbox_patch().set_alpha(0.8) def hover(event): if event.inaxes == ax: for line in ax.get_lines(): cont, ind = line.contains(event) if cont: update_annot(ind, line) annot.set_visible(True) fig.canvas.draw_idle() return annot.set_visible(False) fig.canvas.draw_idle() fig.canvas.mpl_connect("motion_notify_event", hover) last_update_time = current_time return ax, # Start WebSocket in aparte thread def start_websocket(): ws = websocket.WebSocketApp("wss://voorbeeld.com/stream", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever() # Start WebSocket thread ws_thread = threading.Thread(target=start_websocket, daemon=True) ws_thread.start() # Start animation ani = animation.FuncAnimation(fig, update_plot, interval=1000, blit=False) plt.tight_layout() plt.show() ``` **Benodigde packages:** ```bash pip install websocket-client seaborn matplotlib pandas ``` **Belangrijke kenmerken van deze oplossing:** 1. **Realtime WebSocket verbinding** - Verbindt met `wss://voorbeeld.com/stream` 2. **JSON parsing** - Verwerkt data met `tijdstempel`, `sensor_id`, `waarde` velden 3. **10-seconden update interval** - Update de visualisatie elke 10 seconden 4. **Interactieve tooltips** - Toont exacte waarden bij hover over datapunten 5. **Multi-sensor ondersteuning** - Verschillende kleuren voor verschillende sensor_ids 6. **Data buffer** - Beperkt geheugengebruik door oude data te verwijderen **Extra features:** - Responsieve tooltips met tijd en waarde informatie - Automatische kleurtoewijzing voor verschillende sensors - Tijdformattering op x-as - Grid lines voor betere leesbaarheid - Legenda voor sensor identificatie De visualisatie wordt automatisch bijgewerkt terwijl nieuwe data binnenkomt via de WebSocket verbinding.