Line Series

import lightningchart as lc
import random

lc.set_license('my-license-key')

x_values = list(range(0, 100))
y_values = []
y = 0
for i in range(100):
    y += random.random() * 2 - 1
    y_values.append(y)

chart = lc.ChartXY(
    theme=lc.Themes.Light,
    title='Line Series'
)

series = chart.add_line_series().append_samples(
    x_values=x_values,
    y_values=y_values
)
chart.open()

Multi-Channel EEG Signals

import time
import math
import random
import lightningchart as lc

lc.set_license('my-license-key')

# Config
random.seed(0)
NUM_CHANNELS = 5
SAMPLE_RATE_HZ = 100           # points per second per channel
WINDOW_SECONDS = 30            # visible time window
CHANNEL_NAMES = [f'CH{i+1}' for i in range(NUM_CHANNELS)]

# Chart setup
chart = lc.ChartXY(theme=lc.Themes.Light, title='EEG data monitoring (synthetic)')
chart.get_default_y_axis().dispose()

series_list = []
for i, name in enumerate(CHANNEL_NAMES):
    axis_y = chart.add_y_axis(stack_index=i)
    axis_y.set_title(title=name)
    series = chart.add_line_series(
        y_axis=axis_y, 
        schema={
            'x': {'pattern': 'progressive'},
            'y': {'pattern': None},
            }
    )
    series.set_name(name)
    series_list.append(series)

chart.get_default_x_axis() \
    .set_title('Time (s)') \
    .set_scroll_strategy('scrolling') \
    .set_interval(-WINDOW_SECONDS, 0, stop_axis_after=False)

# Open chart
chart.open(live=True)

# Synthetic signal generators 
base_freqs = [0.2 + 0.1*i for i in range(NUM_CHANNELS)]  # Hz
drifts = [0.02 * (i+1) for i in range(NUM_CHANNELS)]     # slow drift amplitude
phases = [random.uniform(0, 2*math.pi) for _ in range(NUM_CHANNELS)]
noise_amp = 0.2

t0 = time.perf_counter()
dt = 1.0 / SAMPLE_RATE_HZ

while True:
        t = time.perf_counter() - t0       # seconds since start
        x = t - WINDOW_SECONDS             # align to [-WINDOW_SECONDS, 0] view

        for i, series in enumerate(series_list):
            y = math.sin(2 * math.pi * base_freqs[i] * t + phases[i])
            y += 0.5 * math.sin(2 * math.pi * (base_freqs[i]*2.3) * t + phases[i]/2)
            y += drifts[i] * math.sin(2 * math.pi * 0.01 * t)
            y += random.uniform(-noise_amp, noise_amp)

            series.add(x, y)
        time.sleep(dt)