Realtime Ghosted Traces

Demonstrates real-time oscilloscope style effects with SciChart.js, High Performance JavaScript Charts

# DataPoints: 0
FPS: 00
# Series: 0 
src/drawExample.ts
import {
    CentralAxesLayoutManager,
    EAxisAlignment,
    EInnerAxisPlacementCoordinateMode,
    FastLineRenderableSeries,
    GlowEffect,
    ICentralAxesLayoutManagerOptions,
    NumberRange,
    NumericAxis,
    SciChartSurface,
    XyDataSeries,
} from "scichart";
import { ExampleDataProvider } from "./ExampleDataProvider";
import { appTheme } from "./appTheme";
// import { PerformanceMeasurementModifier } from "scichart-addons/PerformanceMeasurementModifier";

const AMPLITUDE = 200;

export const drawExample = async (rootElement: string | HTMLDivElement) => {
    const { wasmContext, sciChartSurface } = await SciChartSurface.create(rootElement, {
        theme: appTheme.SciChartJsTheme,
    });

    // Optional parameters to control exact placement of the axis
    // Below: These are defaults, but we specify them for completeness of the example
    // Relative coordinate mode and 0.5 means 'place half way'
    const options: ICentralAxesLayoutManagerOptions = {
        horizontalAxisPositionCoordinateMode: EInnerAxisPlacementCoordinateMode.Relative,
        verticalAxisPositionCoordinateMode: EInnerAxisPlacementCoordinateMode.Relative,
        horizontalAxisPosition: 0.5,
        verticalAxisPosition: 0.5,
    };

    // Configure x,y axis with central layout - oscilloscope style
    sciChartSurface.xAxes.add(
        new NumericAxis(wasmContext, {
            visibleRange: new NumberRange(0, 900),
            isInnerAxis: true,
            axisAlignment: EAxisAlignment.Top,
            axisBorder: {
                borderTop: 1,
            },
        })
    );

    sciChartSurface.yAxes.add(
        new NumericAxis(wasmContext, {
            visibleRange: new NumberRange(-300, 300),
            isInnerAxis: true,
            axisAlignment: EAxisAlignment.Left,
            axisBorder: {
                borderLeft: 1,
            },
        })
    );

    // Control the placement of the axis by specifying CentralAxesLayoutManager
    // and isInnerAxis property
    sciChartSurface.layoutManager = new CentralAxesLayoutManager(options);

    // sciChartSurface.chartModifiers.add(new PerformanceMeasurementModifier({ verbose: true }));

    const addSeries = (stroke: string, opacity: number) => {
        const amplitude = Math.random() * AMPLITUDE;
        const effect = new GlowEffect(wasmContext, {
            range: 0,
            intensity: 0.5,
        });
        const { xValues, yValues } = ExampleDataProvider.getNoisySinewave(500, 900, 7, amplitude, 30);
        const lineSeries = new FastLineRenderableSeries(wasmContext, {
            dataSeries: new XyDataSeries(wasmContext, { xValues, yValues }),
            stroke,
            effect,
            strokeThickness: 3,
            opacity,
        });
        sciChartSurface.renderableSeries.add(lineSeries);
        return lineSeries;
    };

    const seriesColor = appTheme.VividTeal;
    const series1 = addSeries(seriesColor, 1);
    const series2 = addSeries(seriesColor, 0.9);
    const series3 = addSeries(seriesColor, 0.8);
    const series4 = addSeries(seriesColor, 0.7);
    const series5 = addSeries(seriesColor, 0.6);
    const series6 = addSeries(seriesColor, 0.5);
    const series7 = addSeries(seriesColor, 0.4);
    const series8 = addSeries(seriesColor, 0.3);
    const series9 = addSeries(seriesColor, 0.2);
    const series10 = addSeries(seriesColor, 0.1);

    let timerId: NodeJS.Timeout;

    const reassignRenderableSeries = () => {
        const oldSeries = series10.dataSeries;
        series10.dataSeries = series9.dataSeries;
        series9.dataSeries = series8.dataSeries;
        series8.dataSeries = series7.dataSeries;
        series7.dataSeries = series6.dataSeries;
        series6.dataSeries = series5.dataSeries;
        series5.dataSeries = series4.dataSeries;
        series4.dataSeries = series3.dataSeries;
        series3.dataSeries = series2.dataSeries;
        series2.dataSeries = series1.dataSeries;

        const amplitude = Math.random() * AMPLITUDE;
        const dataSeries = new XyDataSeries(wasmContext);
        ExampleDataProvider.fillNoisySinewave(500, 900, 7, amplitude, 30, dataSeries);
        series1.dataSeries = dataSeries;
        // To prevent memory leak we should delete
        oldSeries.delete();

        timerId = setTimeout(reassignRenderableSeries, 20);
    };

    const stopUpdate = () => {
        clearTimeout(timerId);
        timerId = undefined;
    };

    // Buttons for chart
    const startUpdate = () => {
        if (timerId) {
            stopUpdate();
        }
        reassignRenderableSeries();
    };

    return { wasmContext, sciChartSurface, controls: { startUpdate, stopUpdate } };
};

Realtime Ghosted Traces - React Example

Overview

This example demonstrates a high-performance, real-time oscilloscope chart implemented in a React framework using SciChart.js. It renders multiple line series with dynamic ghosted trace effects, where older data fades gradually, providing a visually engaging history of data changes.

Technical Implementation

The chart is initialized within a React component using the <SciChartReact/> component. Once the asynchronous creation of the SciChartSurface completes, NumericAxis and several FastLineRenderableSeries are instantiated and configured. A timer-based mechanism continuously reassigns data series between the traces to simulate the fading "ghost" effect. The real-time data streaming approach is detailed in the Adding Realtime Updates | JavaScript Chart Documentation and leverages React Hooks such as useState and useRef for state management and lifecycle handling. shared CSS controls are used to provide interactive controls, illustrating best practices in integrating UI libraries with SciChart.js as discussed in React Charts with SciChart.js: Introducing “SciChart React”.

Features and Capabilities

  • Real-Time Data Streaming: The chart is continuously updated using a timer that reassigns data between series, effectively simulating live data arrival.
  • Ghosted Trace Effects: Each series is rendered with a different opacity level as well as a GlowEffect to create a fading trail effect, offering a persistent visual history of previous data points.
  • Performance Optimization: Utilizing WebGL for rendering and efficient memory management ensures smooth animations and high frame rates even during frequent updates. Developers can refer to the Performance Tips & Tricks | JavaScript Chart Documentation for further performance considerations.

Integration and Best Practices

This example showcases robust React integration by encapsulating the chart logic within dedicated components and managing state via React Hooks. The <SciChartReact/> component abstracts boilerplate code for initializing and disposing of the chart, while shared CSS controls integration demonstrates effective UI control usage. For developers seeking to build similar implementations, resources such as Creating a SciChart React Component from the Ground Up provide additional guidance on best practices and component lifecycle management. Overall, the example combines advanced charting features with modern React methodologies to offer an optimal real-time data visualization solution.