funcs/plot_func.py

import json
import matplotlib

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

matplotlib.use('Agg')
plt.style.use('ggplot')

def plot_sensor_data_from_json(json_file, sensor, slice_select=1):
    # Read the JSON file
    try:
        with open(json_file, "r") as f:
            slices = json.load(f)
    except:
        with open(json_file.name, "r") as f:
            slices = json.load(f)

    # Concatenate the slices and create a new timestamp series with 20ms intervals
    timestamps = []
    sensor_data = []
    slice_item = []
    temp_end = 0
    for slice_count, slice_dict in enumerate(slices):
        start_timestamp = slice_dict["timestamp"]
        slice_length = len(slice_dict[sensor])

        slice_timestamps = [start_timestamp + 20 * i for i in range(temp_end, slice_length + temp_end)]
        timestamps.extend(slice_timestamps)
        sensor_data.extend(slice_dict[sensor])

        temp_end += slice_length
        slice_item.extend([slice_count+1]*len(slice_timestamps))

    # Create a DataFrame with the sensor data
    data = pd.DataFrame({sensor: sensor_data, 'slice selection': slice_item, 'time': timestamps})

    # Plot the sensor data
    fig, ax = plt.subplots(figsize=(12, 6))
    ax = plt.plot(data['time'].to_list(), data[sensor].to_list())

    df_temp = data[data['slice selection'] == int(slice_select)].reset_index()
    y = [np.NaN]*((int(slice_select)-1)*len(df_temp[sensor].to_list())) + df_temp[sensor].to_list() + [np.NaN]*((len(slices) - int(slice_select))*len(df_temp[sensor].to_list()))
    x = data['time'].to_list()
    ax = plt.plot(x, y, '-')
    
    plt.xlabel("Timestamp")
    plt.ylabel(sensor)
    plt.legend()
    plt.tight_layout()

    fig1, ax1 = plt.subplots(figsize=(12, 6))
    ax1 = plt.plot(df_temp['time'].to_list(), df_temp[sensor].to_list())

    plt.xlabel("Timestamp")
    plt.ylabel(sensor)
    plt.legend()
    plt.tight_layout()

    return fig, fig1, None

def plot_overlay_data_from_json(json_file, sensors, use_precise_timestamp=False):
    # Read the JSON file
    with open(json_file, "r") as f:
        slices = json.load(f)

    # Set up the colormap
    cmap = plt.get_cmap('viridis')

    # Create subplots for each sensor
    fig, axs = plt.subplots(len(sensors), 1, figsize=(12, 2 * len(sensors)), sharex=True)

    for idx, sensor in enumerate(sensors):
        # Plot the overlay of the slices
        for slice_idx, slice_dict in enumerate(slices):
            slice_length = len(slice_dict[sensor])

            # Create timestamp array starting from 0 for each slice
            slice_timestamps = [20 * i for i in range(slice_length)]
            sensor_data = slice_dict[sensor]

            data = pd.DataFrame({sensor: sensor_data}, index=slice_timestamps)
            color = cmap(slice_idx / len(slices))

            axs[idx].plot(data[sensor], color=color, label=f'Slice {slice_idx + 1}')

        axs[idx].set_ylabel(sensor)

    axs[-1].set_xlabel("Timestamp")
    axs[0].legend()

    return fig

def plot_slices(original_signal, imputed_signal, precise_slice_points, normal_slice_points, sample_rate, first_timestamp):
    plt.figure(figsize=(12, 6))
    plt.plot(imputed_signal.index, imputed_signal, label="Imputed Signal")

    # Find the missing values and the predicted values
    missing_value_indices = original_signal.isna()
    missing_values = original_signal.loc[missing_value_indices]
    predicted_values = imputed_signal.loc[missing_value_indices]

    # Plot the original missing values and the predicted values as separate scatter plots
    plt.scatter(missing_values.index, missing_values, color='r', marker='x', label='Original Missing Values')
    plt.scatter(predicted_values.index, predicted_values, color='r', marker='o', label='Predicted Values')

    for index in precise_slice_points:
        plt.axvline(x=first_timestamp + (index), color='r', linestyle='--', label='Precise Slice Points' if index == precise_slice_points[0] else "")
    for index in normal_slice_points:
        plt.axvline(x=first_timestamp + (index), color='g', linestyle='-', label='Normal Slice Points' if index == normal_slice_points[0] else "")
    plt.legend()
    plt.xlabel("Time (s)")
    plt.ylabel("Signal Amplitude")
    plt.title("Imputed Signal and Slice Points")

    return True