Green Driving Data Lab - Plots

# IMPORTS
import datetime
import pandas as pd
import json
import math
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import numpy as np
from urllib.request import urlopen

# Load data
cars = pd.read_csv('plot_files/captured_distance_per_country.csv')  # columns: name, vehicle_cnt, total_distance
with urlopen('https://raw.githubusercontent.com/leakyMirror/map-of-europe/master/GeoJSON/europe.geojson') as response:
    counties = json.load(response)

# Ensure all countries are in the DataFrame
country_ids = [f['properties']['NAME'] for f in counties['features']]

cars = cars.set_index('name').reindex(country_ids)

# fill only numeric columns
num_cols = cars.select_dtypes(include='number').columns
cars[num_cols] = cars[num_cols].fillna(0)

cars = cars.reset_index()

# Create choropleth
fig = go.Figure(go.Choropleth(
    geojson=counties,
    locations=cars['name'],
    z=cars['vehicle_cnt'],
    featureidkey='properties.NAME',
    colorscale='Blues',
    marker_line_color='gray',
    marker_line_width=0.5,
    colorbar=dict(title='Vehicles'),
    # Customize hover to show both vehicle count and total distance
    hovertemplate=(
        "<b>%{location}</b><br>" +
        "Vehicles: %{z}<br>" +
        "Total distance: %{customdata:.0f} km<br>" +
        "<extra></extra>"
    ),
    customdata=cars['distance']  # pass total_distance to hovertemplate
))

# Focus geographic view on Europe
fig.update_geos(
    scope='europe',
    projection_type='natural earth',
    lataxis_range=[36, 73],
    lonaxis_range=[-25, 45],
    showcountries=False,
    showland=False,
    landcolor='pink'
)

fig.update_layout(height=800, margin={'r':0,'t':30,'l':0,'b':0})

fig.show()

trips = pd.read_csv('jrcmatics_trips_aggregated_data.csv')

def add_kpi_card_annotation(
    fig,
    title: str,
    value: str,
    domain_x: tuple,
    domain_y: tuple,
    title_size: int = 24,
    value_size: int = 18,
):
    # Center of the card
    x_center = (domain_x[0] + domain_x[1]) / 2
    y_center = (domain_y[0] + domain_y[1]) / 2

    # Title (slightly above center)
    fig.add_annotation(
        x=x_center,
        y=y_center + 0.08 * (domain_y[1] - domain_y[0]),
        xref="paper",
        yref="paper",
        text=title,
        showarrow=False,
        font=dict(size=title_size),
        align="center",
    )

    # Value (slightly below center)
    fig.add_annotation(
        x=x_center,
        y=y_center - 0.02 * (domain_y[1] - domain_y[0]),
        xref="paper",
        yref="paper",
        text=f"<b>{value}</b>",
        showarrow=False,
        font=dict(size=value_size),
        align="center",
    )

# --- Rounded rectangle path function ---
def rounded_rect_path(x0, y0, x1, y1, r):
    r = min(r, (x1 - x0)/2, (y1 - y0)/2)
    return (
        f"M {x0+r},{y0} "
        f"L {x1-r},{y0} "
        f"Q {x1},{y0} {x1},{y0+r} "
        f"L {x1},{y1-r} "
        f"Q {x1},{y1} {x1-r},{y1} "
        f"L {x0+r},{y1} "
        f"Q {x0},{y1} {x0},{y1-r} "
        f"L {x0},{y0+r} "
        f"Q {x0},{y0} {x0+r},{y0} Z"
    )

# --- Prepare KPI data ---
tot_distance = int(trips["distance"].sum())
total_seconds = int(trips["duration"].sum())
days, remainder = divmod(total_seconds, 86400)
hours, _ = divmod(remainder, 3600)
formatted_tot_time = f"{days} days,<br>{hours:02d} hours"

mean_fc = float(round((trips["fuel"].sum() * 100) / trips["distance"].sum(), 2)) if trips["distance"].sum() else 0

trips["urban distance"] = trips["urban_share"] * trips["distance"]
trips["rural distance"] = trips["rural_share"] * trips["distance"]
trips["motorway distance"] = trips["motorway_share"] * trips["distance"]

# --- KPI definitions ---
kpi_values = [
    {"title": "Total distance collected [km]", "value": tot_distance, "type": "number"},
    {"title": "Total driving time [days, HH]", "value": formatted_tot_time, "type": "string"},
    {"title": "Mean Fuel Consumption [L/100*km]", "value": mean_fc, "type": "number", "suffix": "%"},
    {"title": "Captured urban distance [km]", "value": int(trips["urban distance"].sum()), "type": "number"},
    {"title": "Captured rural distance [km]", "value": int(trips["rural distance"].sum()), "type": "number"},
    {"title": "Captured motorway distance [km]", "value": int(trips["motorway distance"].sum()), "type": "number"},
]

# --- Card positions ---
card_positions = [
    (0.03, 0.48, 0.32, 0.95),
    (0.33, 0.48, 0.62, 0.95),
    (0.63, 0.48, 0.92, 0.95),
    (0.03, 0.00, 0.32, 0.43),
    (0.33, 0.00, 0.62, 0.43),
    (0.63, 0.00, 0.92, 0.43),
]

# --- Helper function to wrap text ---
def wrap_text(text, max_chars_per_line=25):
    """Wrap text to fit within card width"""
    words = text.split()
    lines = []
    current_line = []
    current_length = 0
    
    for word in words:
        if current_length + len(word) + len(current_line) <= max_chars_per_line:
            current_line.append(word)
            current_length += len(word)
        else:
            if current_line:
                lines.append(' '.join(current_line))
            current_line = [word]
            current_length = len(word)
    
    if current_line:
        lines.append(' '.join(current_line))
    
    return '<br>'.join(lines)

# --- Helper function to calculate font size ---
def calculate_title_font_size(text, card_width):
    """Calculate appropriate font size based on text length and card width"""
    # Approximate characters that can fit at different font sizes
    # Assuming roughly 100 pixels per 0.1 paper units at font size 15
    base_char_capacity = card_width * 200  # rough estimate
    text_length = len(text)
    
    if text_length <= base_char_capacity / 15:
        return 15
    elif text_length <= base_char_capacity / 12:
        return 13
    else:
        return 11

def calculate_value_font_size(value_str, card_width):
    """Calculate appropriate font size for value based on length"""
    str_len = len(str(value_str))
    
    if str_len <= 6:
        return 44
    elif str_len <= 10:
        return 38
    elif str_len <= 15:
        return 32
    else:
        return 26

# --- Create figure ---
fig = go.Figure()

for kpi, pos in zip(kpi_values, card_positions):
    x0, y0, x1, y1 = pos
    domain_x = [x0 + 0.02, x1 - 0.02]
    domain_y = [y0 + 0.02, y1 - 0.02]
    card_height = y1 - y0
    card_width = x1 - x0
    
    # Calculate dynamic font sizes
    title_font_size = calculate_title_font_size(kpi["title"], card_width)
    
    # Wrap title text if needed
    wrapped_title = wrap_text(kpi["title"], max_chars_per_line=int(card_width * 80))

    if kpi["type"] == "number":
        # Calculate value font size
        value_font_size = calculate_value_font_size(kpi["value"], card_width)
        
        number_config = {"suffix": kpi.get("suffix", "")} if "suffix" in kpi else None
        fig.add_trace(go.Indicator(
            mode="number",
            value=kpi["value"],
            title={"text": wrapped_title, "font": {"size": title_font_size}},
            number={"valueformat": None, "font": {"size": value_font_size}, **(number_config or {})},
            domain={'x': domain_x, 'y': domain_y}
        ))
    else:
        # Properly aligned annotation for string values
        x_center = (x0 + x1) / 2
        
        # Check if value is multi-line (contains <br>)
        is_multiline = '<br>' in kpi["value"]
        
        # For multi-line values, calculate size based on the longest line
        if is_multiline:
            lines = kpi["value"].split('<br>')
            max_line_length = max(len(line) for line in lines)
            value_font_size = calculate_value_font_size(max_line_length, card_width)
            # Increase font size significantly for multi-line since each line is shorter
            value_font_size = min(value_font_size + 12, 44)
        else:
            value_font_size = calculate_value_font_size(kpi["value"], card_width)

        # Align title just above the center of the card, like Indicator
        title_y = y1 - card_height * 0.15  # roughly where Indicator titles sit
        value_y = y1 - card_height * 0.35  # value slightly below the title, centered visually

        # Title
        fig.add_annotation(
            x=x_center, y=title_y,
            text=wrapped_title,
            showarrow=False,
            xref="paper", yref="paper",
            font=dict(size=title_font_size),
            align="center"
        )

        # Value
        fig.add_annotation(
            x=x_center, y=value_y,
            text=kpi["value"],
            showarrow=False,
            xref="paper", yref="paper",
            font=dict(size=max(value_font_size - 22, 16)),  # ensure minimum readable size
            align="center"
        )

# --- Add card shapes ---
fig.update_layout(
    shapes=[
        dict(
            type="path",
            path=rounded_rect_path(*pos, r=0.03),
            xref="paper", yref="paper",
            fillcolor="white",
            line=dict(color="#D3D3D3", width=1),
            layer="below"
        ) for pos in card_positions
    ],
    height=400,
    margin=dict(l=40, r=0, t=0, b=20)
)

fig.show()

# Create diplayable values
dist = f"{tot_distance//1000}k"
trips_cnt = len(trips)
cars_cnt = len(cars)

def total_distance_vs_fuel_consumption(data: pd.DataFrame):
    """Total distance vs fuel consumption plot

    Parameters
    ----------
    data : pd.DataFrame
        All agregated data.
    """

    mapping = {
        "HEV": "Hybrid",
        "MHEV": "Mild hybrid",
        "PHEV": "Plug-in hybrid",
        "conventional": "Conventional",
        "ICE": "ICE",
        "ICEV": "Conventional",
        "UNKNOWN": "UNKNOWN"
    }

    data2plot = data[(data["distance"] >= 1.7) & (data["distance"] < 250)].copy()

    data2plot["Fuel consumption [l/100km]"] = data2plot.apply(lambda x: (x["fuel"] * 100) / x["distance"], axis=1)
    data2plot["Vehicle type"] = data2plot["type"].apply(lambda x: mapping[x])
    data2plot["Trip distance [km]"] = data2plot["distance"].apply(lambda x: x)

    fig = px.scatter(data2plot, x="Fuel consumption [l/100km]", y="Trip distance [km]", color="Vehicle type",
                     marginal_x="histogram", marginal_y="histogram", opacity=0.6,
                     color_continuous_scale=["rgb(239,200,89)", "rgb(177,88,164)", "rgb(116,194,184)"])

    return fig

fig = total_distance_vs_fuel_consumption(trips)
fig.show()

fleet_df = pd.read_csv("plot_files/fleet_composition.csv", index_col=0)
fleet_df.columns.values[0] = "cnt"

fig = go.Figure(
    go.Pie(
        labels=fleet_df["ft_type"],
        values=fleet_df["cnt"],
        hole=0.3,  # make a donut chart if you want
        marker=dict(colors=px.colors.qualitative.Pastel)
    )
)

fig.update_layout(title="Fleet Composition")
fig.show()

def avg_speed_dist(data: pd.DataFrame):
    """Average speed distribution plot.

    Parameters
    ----------
    data : pd.DataFrame
        All agregated data.
    """
    data2plot = pd.DataFrame()

    data2plot["Mean speed per trip [km/h]"] = data["mean_speed"].values

    fig = px.histogram(data2plot, x="Mean speed per trip [km/h]", title="Speed Distribution", nbins=200)

    fig.update_traces(marker_color='rgb(144,207,223)', marker_line_color='rgb(144,207,223)',
                      marker_line_width=1.5, opacity=0.6)

    return fig

def avg_amb_temp_dist(data: pd.DataFrame):
    """Average speed distribution plot.

    Parameters
    ----------
    data : pd.DataFrame
        All agregated data.
    """
    data2plot = pd.DataFrame()

    data2plot["Mean ambient temperature [ºC]"] = data[data["mean_ambient_temp"].notnull()]["mean_ambient_temp"].values

    fig = px.histogram(data2plot, x="Mean ambient temperature [ºC]", title="Ambient Temperature Distribution", nbins=70)

    fig.update_traces(marker_color='rgb(94,124,199)', marker_line_color='rgb(94,124,199)',
                      marker_line_width=1.5, opacity=0.6)

    return fig

fig = make_subplots(
    rows=1,
    cols=2,
    subplot_titles=("Speed Distribution", "Ambient Temperature Distribution")
)

avg_speed_plot = avg_speed_dist(trips)
avg_amb_temp_plot = avg_amb_temp_dist(trips)
# Add all traces from PX figure to subplot
for trace in avg_speed_plot.data:
    fig.add_trace(trace, row=1, col=1)

for trace in avg_amb_temp_plot.data:
    fig.add_trace(trace, row=1, col=2)

fig.update_layout(
    template="plotly_white",
    height=400,
    bargap=0.05,
    showlegend=False
)

def daily_driving_time(data: pd.DataFrame):
    """Dayly driving time plot

    Parameters
    ----------
    data : pd.DataFrame
        All agregated data.
    """

    # Extract the weekday (0=Monday, 6=Sunday)
    data["weekday"] = data["min_time_corr_dt"].dt.day_name()

    time_driving_df = data.groupby("weekday")["duration"].sum()

    time_driving_df_plot = pd.DataFrame()

    time_driving_df_plot["weekday"] = time_driving_df.index
    time_driving_df_plot["Time share"] = (time_driving_df.values / np.sum(time_driving_df.values)) * 100

    fig = px.bar(time_driving_df_plot, x="weekday", y="Time share", title="Daily driving time")

    fig.update_xaxes(categoryorder='array',
                     categoryarray=["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])

    fig.update_traces(marker_color='rgb(238,184,155)', marker_line_color='rgb(238,184,155)',
                      marker_line_width=1.5, opacity=0.6)

    return fig


def daily_driving_distance(data: pd.DataFrame):
    """Daily driving time plot

    Parameters
    ----------
    data : pd.DataFrame
        All agregated data.
    """

    # Extract the weekday (0=Monday, 6=Sunday)
    data["weekday"] = data["min_time_corr_dt"].dt.day_name()

    distance_driving_df = data.groupby("weekday")["distance"].sum()

    distance_driving_df_plot = pd.DataFrame()

    distance_driving_df_plot["weekday"] = distance_driving_df.index
    distance_driving_df_plot["Distance share"] = (distance_driving_df.values / np.sum(distance_driving_df.values)) * 100

    fig = px.bar(distance_driving_df_plot, x="weekday", y="Distance share", title="Daily driven distance")

    fig.update_xaxes(categoryorder='array',
                     categoryarray=["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])

    fig.update_traces(marker_color='rgb(214,123,99)', marker_line_color='rgb(214,123,99)',
                      marker_line_width=1.5, opacity=0.6)

    return fig

# Create dt field for weekday extraction
trips["min_time_corr_dt"] = pd.to_datetime(trips["min_datetime"])

fig = make_subplots(
    rows=1,
    cols=2,
    subplot_titles=("Daily Driving Time", "Daily Driving Distance")
)

daily_driving_time = daily_driving_time(trips)
daily_driving_distance = daily_driving_distance(trips)
# Add all traces from PX figure to subplot
for trace in daily_driving_time.data:
    fig.add_trace(trace, row=1, col=1)

for trace in daily_driving_distance.data:
    fig.add_trace(trace, row=1, col=2)

fig.update_layout(
    template="plotly_white",
    height=400,
    bargap=0.05,
    showlegend=False
)

# Load data
network_dist_df = pd.read_csv("plot_files/monthly_distance_shares.csv")

# Parse month/year, create abbreviated month, sort ascending
network_dist_df['month_parsed'] = pd.to_datetime(
    network_dist_df['month'].astype(str).str.strip(), format="%m/%Y", errors='coerce'
)
network_dist_df['month_abbr'] = network_dist_df['month_parsed'].dt.strftime('%b')
network_dist_df = network_dist_df.sort_values('month_parsed', na_position='last').reset_index(drop=True)
network_dist_df.drop(columns=['month_parsed', 'month'], inplace=True)

# Optional: define custom colors (replace with your BASE_COLOR logic)
similar_colors = ['#4C78A8', '#F58518', '#54A24B']

# Create line chart
fig = go.Figure()

# Urban Distance
fig.add_trace(go.Scatter(
    x=network_dist_df['month_abbr'],
    y=network_dist_df['urban_distance_share'],
    mode='lines+markers',
    name='Urban Dist',
    line=dict(shape='spline', color=similar_colors[0]),
))
# Add average line
fig.add_hline(y=network_dist_df['urban_distance_share'].mean(), line_dash="dash",
              annotation_text="Avg", annotation_position="top left", line_color=similar_colors[0])

# Rural Distance
fig.add_trace(go.Scatter(
    x=network_dist_df['month_abbr'],
    y=network_dist_df['rural_distance_share'],
    mode='lines+markers',
    name='Rural Dist',
    line=dict(shape='spline', color=similar_colors[1]),
))
fig.add_hline(y=network_dist_df['rural_distance_share'].mean(), line_dash="dash",
              annotation_text="Avg", annotation_position="top left", line_color=similar_colors[1])

# Motorway Distance
fig.add_trace(go.Scatter(
    x=network_dist_df['month_abbr'],
    y=network_dist_df['motorway_distance_share'],
    mode='lines+markers',
    name='Motorway Dist',
    line=dict(shape='spline', color=similar_colors[2]),
))
fig.add_hline(y=network_dist_df['motorway_distance_share'].mean(), line_dash="dash",
              annotation_text="Avg", annotation_position="top left", line_color=similar_colors[2])

# Update layout
fig.update_layout(
    title="Network Distance by Month",
    xaxis_title="Month",
    yaxis_title="Distance Share",
    template="plotly_white",
    showlegend=True,
    height=400
)

fig.show()