Demonstrates real-time oscilloscope style effects with SciChart.js, High Performance JavaScript Charts
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 } };
};
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.
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”.
GlowEffect to create a fading trail effect, offering a persistent visual history of previous data points.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.











