%pip install numpy pandas lightningchart

# Import necessary libraries (load pandas library to preprocess dataset)
import pandas as pd

# Chart 1 - Body Temperature vs Abnormal Alert Load 
# Developed with AI assistance to demonstrate LightningChart Python

import lightningchart as lc
import numpy as np
import pandas as pd
# License
with open("D:/HAMK/Internship/MyProjects/lc_license.txt", "r") as f:
    lc.set_license(f.read().strip())
# Compute abnormal_count per row
alert_cols = [
    'heart_rate_alert',
    'spO2_level_alert',
    'blood_pressure_alert',
    'temperature_alert'
]

def abnormal_score(row):
    return sum(1 for c in alert_cols if row[c] == 'ABNORMAL')

if 'abnormal_count' not in pdhmsd.columns:
    pdhmsd['abnormal_count'] = pdhmsd.apply(abnormal_score, axis=1)

# We'll also clip abnormal_count into 0,1,2,3,4+ categories for nicer layering
def bucket_abn(n):
    return str(n) if n < 4 else '4+'

pdhmsd['abn_bucket'] = pdhmsd['abnormal_count'].apply(bucket_abn)

# Create chart
chart = lc.ChartXY(
    title='Body Temperature vs Multi-Vital Abnormality', html_text_rendering=True, 
    theme=lc.Themes.White
)

x_axis = chart.get_default_x_axis()
y_axis = chart.get_default_y_axis()

x_axis.set_title('Body Temperature (°C)')
y_axis.set_title('Simultaneous abnormal vital alerts')

# Add one Point Series per severity bucket
severity_levels = ['0', '1', '2', '3', '4+']
for level in severity_levels:
    subset = pdhmsd[pdhmsd['abn_bucket'] == level]

    ps = chart.add_point_series()
    ps.set_name(f'{level} abnormal alerts')

    # Optional: make higher severity more visually bold (bigger points)
    # Different builds may use set_point_size or set_point_style.
    if hasattr(ps, 'set_point_size'):
        if level == '0':
            ps.set_point_size(2)
        elif level == '1':
            ps.set_point_size(3)
        elif level == '2':
            ps.set_point_size(4)
        elif level == '3':
            ps.set_point_size(5)
        else:  # '4+'
            ps.set_point_size(6)

    # Add the actual points.
    # For visibility (avoid perfect horizontal stripes), add tiny jitter vertically.
    jitter = (np.random.random(len(subset)) - 0.5) * 0.05
    y_vals = subset['abnormal_count'].to_numpy(dtype=float) + jitter
    x_vals = subset['body_temperature'].to_numpy(dtype=float)

    # LightningChart series usually accept list of dicts [{'x':..., 'y':...}, ...]
    ps.add([
        {'x': float(xv), 'y': float(yv)}
        for xv, yv in zip(x_vals, y_vals)
    ])

chart.open()

# Chart 2 - Blood Pressure Stability Stream (Scrolling 3D Surface)
# Developed with AI assistance to demonstrate LightningChart Python
import lightningchart as lc
import numpy as np
import time
# License
with open("D:/HAMK/Internship/MyProjects/lc_license.txt", "r") as f:
    lc.set_license(f.read().strip())
# 1. Compute Mean Arterial Pressure (MAP)
sbp = pdhmsd['systolic_blood_pressure'].to_numpy(dtype=float)
dbp = pdhmsd['diastolic_blood_pressure'].to_numpy(dtype=float)
map_values = (sbp + 2.0 * dbp) / 3.0

# clip extreme outliers so the surface doesn't spike to nonsense
map_values = np.clip(map_values, 40, 160)

# 2. Chunk MAP into frames for streaming
columns_amount = 100
rows_amount = 100

def make_chunks(values, chunk_size):
    for i in range(0, len(values), chunk_size):
        chunk = values[i:i+chunk_size]
        if len(chunk) < chunk_size:
            chunk = np.pad(chunk, (0, chunk_size - len(chunk)), mode='edge')
        yield chunk

frames = list(make_chunks(map_values, columns_amount))
if len(frames) == 0:
    raise RuntimeError("Not enough BP data to generate surface frames.")

# 3. Build 3D scrolling surface chart
chart = lc.Chart3D(
    theme=lc.Themes.Dark,
    title='Blood Pressure Stability Stream (MAP over time)', html_text_rendering=True,
)

surface = chart.add_surface_scrolling_grid_series(
    columns=columns_amount,
    rows=rows_amount
)

# Color palette: lower MAP = blue/green, higher MAP = yellow/red
surface.set_palette_coloring(
    steps=[
        {'value': 40,  'color': ('navy')},
        {'value': 70,  'color': ('blue')},
        {'value': 90,  'color': ('green')},
        {'value': 110, 'color': ('yellow')},
        {'value': 140, 'color': ('red')}
    ],
    look_up_property='value',
    percentage_values=False
)

# Pre-fill the surface so it's not empty when it opens
init_buffer = []
for r in range(rows_amount):
    frame_idx = min(r, len(frames) - 1)
    init_buffer.append(frames[frame_idx].tolist())

surface.add_values(
    y_values=init_buffer,
    intensity_values=init_buffer
)

# ✨ NEW: label axes with medical meaning
x_axis_3d = chart.get_default_x_axis()
y_axis_3d = chart.get_default_y_axis()
z_axis_3d = chart.get_default_z_axis()

# X axis = parallel samples in the same frame (patients / channels)
x_axis_3d.set_title('Parallel patient samples (index)') # Parallel patient samples (index within frame)

# Y axis = physical height of surface = MAP
y_axis_3d.set_title('MAP (mmHg) - Cardiovascular load')

# Z axis = scroll direction = time
z_axis_3d.set_title('Time (incoming frames ->)')

# stream live
chart.open(live=True)

for frame in frames:
    row_list = frame.tolist()
    surface.add_values(
        y_values=[row_list],
        intensity_values=[row_list]
    )
    time.sleep(0.05)

chart.close()

# Chart 3 - Heart Rate Risk Envelope (3D Vitals Point Cloud)
# Developed with AI assistance to demonstrate LightningChart Python

import lightningchart as lc
import numpy as np
import pandas as pd

# License
with open("D:/HAMK/Internship/MyProjects/lc_license.txt", "r") as f:
    lc.set_license(f.read().strip())

# Split dataframe by HR alert state
stable_df   = pdhmsd[pdhmsd['heart_rate_alert'] == 'NORMAL']
critical_df = pdhmsd[pdhmsd['heart_rate_alert'] == 'ABNORMAL']

# Create 3D chart
chart3d = lc.Chart3D(
    theme=lc.Themes.Light,
    title='Heart Rate Risk Envelope (Heart Rate vs SpO₂ vs Systolic BP)',
    html_text_rendering=True,
)

# Add one 3D point series for stable vitals
series_stable = chart3d.add_point_series()
series_stable.set_name('Heart rate NORMAL')

# Add one 3D point series for critical vitals
series_critical = chart3d.add_point_series()
series_critical.set_name('Heart rate ABNORMAL')

# OPTIONAL styling: emphasize critical points
# Some builds support set_point_size() on 3D series, some use set_point_style()
if hasattr(series_stable, 'set_point_size'):
    series_stable.set_point_size(3)
if hasattr(series_critical, 'set_point_size'):
    series_critical.set_point_size(5)

# Add stable points
series_stable.add([
    {
        'x': float(hr),
        'y': float(spo2),
        'z': float(sys_bp),
        'label': f'HR={hr}, SpO2={spo2}, SysBP={sys_bp}, HRalert=NORMAL'
    }
    for hr, spo2, sys_bp in zip(
        stable_df['heart_rate'],
        stable_df['spO2_level'],
        stable_df['systolic_blood_pressure']
    )
])

# Add critical points
series_critical.add([
    {
        'x': float(hr),
        'y': float(spo2),
        'z': float(sys_bp),
        'label': f'HR={hr}, SpO2={spo2}, SysBP={sys_bp}, HRalert=ABNORMAL'
    }
    for hr, spo2, sys_bp in zip(
        critical_df['heart_rate'],
        critical_df['spO2_level'],
        critical_df['systolic_blood_pressure']
    )
])

# Label axes with physiological meaning
x_axis = chart3d.get_default_x_axis()
y_axis = chart3d.get_default_y_axis()
z_axis = chart3d.get_default_z_axis()

x_axis.set_title('Heart Rate (bpm)')
y_axis.set_title('SpO₂ level (%)')
z_axis.set_title('Systolic BP (mmHg)')

# Optional: you can also play with camera/orbit interactively in runtime
chart3d.open()