Using the SubCharts API as part of SciChart.js, this demo showcases an 8x8 grid of 64 charts updating in realtime in JavaScript.
import {
appendData,
createRenderableSeries,
generateData,
getDataSeriesTypeForRenderableSeries,
getSubChartPositionIndexes,
prePopulateData,
} from "./helpers";
import {
BaseDataSeries,
ESubSurfacePositionCoordinateMode,
EDataSeriesType,
EAutoRange,
ENumericFormat,
ESeriesType,
IRenderableSeries,
INumericAxisOptions,
I2DSubSurfaceOptions,
NumericAxis,
NumberRange,
Rect,
RightAlignedOuterVerticallyStackedAxisLayoutStrategy,
SciChartSubSurface,
SciChartSurface,
StackedColumnCollection,
StackedColumnRenderableSeries,
StackedMountainCollection,
StackedMountainRenderableSeries,
Thickness,
TSciChart,
} from "scichart";
import { appTheme } from "./appTheme";
export type TMessage = {
title: string;
detail: string;
};
const axisOptions: INumericAxisOptions = {
useNativeText: true,
isVisible: false,
drawMajorBands: false,
drawMinorGridLines: false,
drawMinorTickLines: false,
drawMajorTickLines: false,
drawMajorGridLines: false,
labelStyle: { fontSize: 8 },
labelFormat: ENumericFormat.Decimal,
labelPrecision: 0,
autoRange: EAutoRange.Always,
};
// theme overrides
const sciChartTheme = appTheme.SciChartJsTheme;
export const drawGridExample = async (
rootElement: string | HTMLDivElement,
updateMessages: (newMessages: TMessage[]) => void
) => {
const subChartsNumber = 64;
const columnsNumber = 8;
const rowsNumber = 8;
const dataSettings = {
seriesCount: 3,
pointsOnChart: 5000,
sendEvery: 16,
initialPoints: 20,
};
const originalGetStrokeColor = sciChartTheme.getStrokeColor;
let counter = 0;
sciChartTheme.getStrokeColor = (index: number, max: number, context: TSciChart) => {
const currentIndex = counter % subChartsNumber;
counter += 3;
return originalGetStrokeColor.call(sciChartTheme, currentIndex, subChartsNumber, context);
};
const originalGetFillColor = sciChartTheme.getFillColor;
sciChartTheme.getFillColor = (index: number, max: number, context: TSciChart) => {
const currentIndex = counter % subChartsNumber;
counter += 3;
return originalGetFillColor.call(sciChartTheme, currentIndex, subChartsNumber, context);
};
///
const { wasmContext, sciChartSurface: mainSurface } = await SciChartSurface.createSingle(rootElement, {
theme: sciChartTheme,
});
const mainXAxis = new NumericAxis(wasmContext, {
isVisible: false,
id: "mainXAxis",
});
mainSurface.xAxes.add(mainXAxis);
const mainYAxis = new NumericAxis(wasmContext, {
isVisible: false,
id: "mainYAxis",
});
mainSurface.yAxes.add(mainYAxis);
const seriesTypes = [
ESeriesType.LineSeries,
// ESeriesType.BubbleSeries,
//ESeriesType.StackedColumnSeries,
ESeriesType.ColumnSeries,
//ESeriesType.StackedMountainSeries,
ESeriesType.BandSeries,
ESeriesType.ScatterSeries,
ESeriesType.CandlestickSeries,
// ESeriesType.TextSeries
];
const subChartPositioningCoordinateMode = ESubSurfacePositionCoordinateMode.Relative;
const subChartsMap: Map<
SciChartSubSurface,
{ seriesType: ESeriesType; dataSeriesType: EDataSeriesType; dataSeriesArray: BaseDataSeries[] }
> = new Map();
const xValues = Array.from(new Array(dataSettings.initialPoints).keys());
const initSubChart = (seriesType: ESeriesType, subChartIndex: number) => {
// calculate sub-chart position and sizes
const { rowIndex, columnIndex } = getSubChartPositionIndexes(subChartIndex, columnsNumber);
const width = 1 / columnsNumber;
const height = 1 / rowsNumber;
const position = new Rect(columnIndex * width, rowIndex * height, width, height);
// sub-surface configuration
const subChartOptions: I2DSubSurfaceOptions = {
id: `subChart-${subChartIndex}`,
theme: sciChartTheme,
position,
parentXAxisId: mainXAxis.id,
parentYAxisId: mainYAxis.id,
coordinateMode: subChartPositioningCoordinateMode,
padding: Thickness.fromNumber(1),
viewportBorder: {
color: "rgba(150, 74, 148, 0.51)",
border: 2,
},
};
// create sub-surface
const subChartSurface = SciChartSubSurface.createSubSurface(mainSurface, subChartOptions);
// add axes to the sub-surface
const subChartXAxis = new NumericAxis(wasmContext, {
...axisOptions,
id: `${subChartSurface.id}-XAxis`,
growBy: new NumberRange(0.0, 0.0),
useNativeText: true,
});
subChartSurface.xAxes.add(subChartXAxis);
const subChartYAxis = new NumericAxis(wasmContext, {
...axisOptions,
id: `${subChartSurface.id}-YAxis`,
growBy: new NumberRange(0.01, 0.1),
useNativeText: true,
autoRange: EAutoRange.Always,
});
subChartSurface.yAxes.add(subChartYAxis);
// add series to sub-surface
const dataSeriesArray: BaseDataSeries[] = new Array(dataSettings.seriesCount);
const dataSeriesType = getDataSeriesTypeForRenderableSeries(seriesType);
let stackedCollection: IRenderableSeries;
const positive = [ESeriesType.StackedColumnSeries, ESeriesType.StackedMountainSeries].includes(seriesType);
for (let i = 0; i < dataSettings.seriesCount; i++) {
const { dataSeries, rendSeries } = createRenderableSeries(
wasmContext,
seriesType,
subChartXAxis.id,
subChartYAxis.id
);
subChartXAxis.visibleRange = new NumberRange(0, dataSeries.count());
dataSeriesArray[i] = dataSeries;
// add series to the sub-chart and apply additional configurations per series type
if (seriesType === ESeriesType.StackedColumnSeries) {
if (i === 0) {
stackedCollection = new StackedColumnCollection(wasmContext, {
dataPointWidth: 1,
xAxisId: subChartXAxis.id,
yAxisId: subChartYAxis.id,
});
subChartSurface.renderableSeries.add(stackedCollection);
}
(rendSeries as StackedColumnRenderableSeries).stackedGroupId = i.toString();
(stackedCollection as StackedColumnCollection).add(rendSeries as StackedColumnRenderableSeries);
} else if (seriesType === ESeriesType.StackedMountainSeries) {
if (i === 0) {
stackedCollection = new StackedMountainCollection(wasmContext, {
xAxisId: subChartXAxis.id,
yAxisId: subChartYAxis.id,
});
subChartSurface.renderableSeries.add(stackedCollection);
}
(stackedCollection as StackedMountainCollection).add(rendSeries as StackedMountainRenderableSeries);
} else if (seriesType === ESeriesType.ColumnSeries) {
// create Stacked Y Axis
if (i === 0) {
subChartSurface.layoutManager.rightOuterAxesLayoutStrategy =
new RightAlignedOuterVerticallyStackedAxisLayoutStrategy();
rendSeries.yAxisId = subChartYAxis.id;
} else {
const additionalYAxis = new NumericAxis(wasmContext, {
...axisOptions,
id: `${subChartSurface.id}-YAxis${i}`,
});
subChartSurface.yAxes.add(additionalYAxis);
rendSeries.yAxisId = additionalYAxis.id;
}
subChartSurface.renderableSeries.add(rendSeries);
} else {
subChartSurface.renderableSeries.add(rendSeries);
}
// Generate points
prePopulateData(dataSeries, dataSeriesType, xValues, positive);
subChartSurface.zoomExtents(0);
}
subChartsMap.set(subChartSurface, { seriesType, dataSeriesType, dataSeriesArray });
return positive;
};
// generate the subcharts grid
for (let subChartIndex = 0; subChartIndex < subChartsNumber; ++subChartIndex) {
const seriesType = seriesTypes[subChartIndex % seriesTypes.length];
initSubChart(seriesType, subChartIndex);
}
// setup for realtime updates
let isRunning: boolean = false;
const newMessages: TMessage[] = [];
let loadStart = 0;
let avgRenderTime: number = 0;
let dataGenerationStart: DOMHighResTimeStamp;
let dataGenerationEnd: DOMHighResTimeStamp;
let dataAppendStart: DOMHighResTimeStamp;
let dataAppendEnd: DOMHighResTimeStamp;
let renderStart: DOMHighResTimeStamp;
let renderEnd: DOMHighResTimeStamp;
let lastRenderEnd: DOMHighResTimeStamp;
let lastPaintEnd: DOMHighResTimeStamp;
let paintEnd: DOMHighResTimeStamp;
const dataStore = new Map(
mainSurface.subCharts.map((subChart) => [
subChart,
Array.from(Array(dataSettings.seriesCount)).map((_: any) => null as any),
])
);
const updateCharts = () => {
if (!isRunning) {
return;
}
loadStart = new Date().getTime();
dataGenerationStart = performance.now();
subChartsMap.forEach(({ seriesType, dataSeriesArray, dataSeriesType }, subSurface) => {
const pointsToUpdate = Math.round(Math.max(1, dataSeriesArray[0].count() / 50));
for (let i = 0; i < dataSettings.seriesCount; i++) {
dataStore.get(subSurface)[i] = generateData(
seriesType,
dataSeriesArray[i],
dataSeriesType,
i,
dataSettings.pointsOnChart,
pointsToUpdate
);
}
});
dataAppendStart = performance.now();
subChartsMap.forEach(({ seriesType, dataSeriesArray, dataSeriesType }, subSurface) => {
const pointsToUpdate = Math.round(Math.max(1, dataSeriesArray[0].count() / 50));
for (let i = 0; i < dataSettings.seriesCount; i++) {
const data = dataStore.get(subSurface)[i];
appendData(
seriesType,
dataSeriesArray[i],
dataSeriesType,
i,
dataSettings.pointsOnChart,
pointsToUpdate,
data
);
}
});
dataAppendEnd = performance.now();
};
mainSurface.preRenderAll.subscribe(() => {
renderStart = performance.now();
});
// mainSurface.painted.subscribe(() => {
// lastPaintEnd = paintEnd;
// paintEnd = performance.now();
// });
// render time info calculation
mainSurface.renderedToDestination.subscribe(() => {
if (!isRunning || loadStart === 0) return;
lastRenderEnd = renderEnd;
renderEnd = performance.now();
avgRenderTime = renderEnd - renderStart;
const charts = Array.from(subChartsMap.values());
const totalPoints = charts[0].dataSeriesArray[0].count() * dataSettings.seriesCount * charts.length;
// Number of data points on the chart including all of the series on sub-charts
newMessages.push({
title: `Points`,
detail: `${totalPoints}`,
});
// Data points generation time. In a real app data will likely be fetched from a server instead
newMessages.push({
title: `Generate`,
detail: `${(dataAppendStart - dataGenerationStart).toFixed(1)}ms`,
});
// DataSeries collection update time
newMessages.push({
title: `Append`,
detail: `${(dataAppendEnd - dataAppendStart).toFixed(1)}ms`,
});
// SciChart's engine render time of the last frame
newMessages.push({
title: `Render`,
detail: `${avgRenderTime.toFixed(2)}ms`,
});
// // Current FPS value
// newMessages.push({
// title: `FPS`,
// detail: `${(1000 / (renderEnd - lastRenderEnd)).toFixed(1)}`,
// });
// Potentially achievable FPS value considering that data generation step could be omitted on client,
// data is sent at a corresponding delay,
// and display has an appropriate refresh rate
newMessages.push({
title: `Max FPS`,
detail: `${(1000 / (dataAppendEnd - dataAppendStart + avgRenderTime)).toFixed(1)}`,
});
updateMessages(newMessages);
newMessages.length = 0;
});
let timer: NodeJS.Timeout;
// Buttons for chart
const startUpdate = () => {
console.log("start streaming");
avgRenderTime = 0;
loadStart = 0;
isRunning = true;
timer = setInterval(updateCharts, dataSettings.sendEvery);
};
const stopUpdate = () => {
console.log("stop streaming");
isRunning = false;
clearInterval(timer);
};
const setLabels = (show: boolean) => {
subChartsMap.forEach((v, k) => {
k.xAxes.get(0).isVisible = show;
k.yAxes.asArray().forEach((y) => (y.isVisible = show));
});
};
return {
wasmContext,
sciChartSurface: mainSurface,
controls: {
startUpdate,
stopUpdate,
setLabels,
},
};
};
This example demonstrates how to integrate SciChart.js into a React application by constructing an 8x8 grid of 64 sub-charts that update in real-time. By leveraging functional components and React hooks such as useRef and useState, the example provides a robust framework for building high-performance chart dashboards. For futher details please see What is the SubCharts API? and Using SubCharts to create a Large Dashboard.
The implementation establishes a main SciChartSurface and then dynamically creates multiple sub-surfaces using the SciChart SubCharts API. Each sub-chart is configured via JSON-based options that determine properties like axes, layout positions, and chart padding. React is used to manage the lifecycle of these charts via the <SciChartReact/> component, ensuring proper initialization and cleanup. For more detailed guidance on integrating SciChart.js into React, developers can consult Creating a SciChart React Component from the Ground Up.
Key features include real-time data updates, dynamic sub-chart composition, and interactive modifiers. The charts are updated in real-time using high-frequency data streams, a technique detailed in Adding Realtime Updates | JavaScript Chart Documentation - SciChart. Advanced interactive functionalities such as zooming and panning are provided by modifiers like MouseWheelZoomModifier and ZoomPanModifier, enhancing user engagement and data exploration.
The example adheres to best practices for React integration by employing functional components, state management, and efficient cleanup of event subscriptions. Performance optimization is achieved by minimizing unnecessary re-renders and managing WebGL resources effectively, a strategy that aligns with insights from React Charts with SciChart.js: Introducing “SciChart React”. Additionally, the implementation demonstrates best practices in event handling and cleanup, ensuring stable performance even with high-frequency updates, as discussed in ReactJS Sweep Line: Optimizing SciChartJS Performance, Reusing WasmContext for Multiple Charts.
Overall, the Sub Charts API example in React provides a practical blueprint for building complex, interactive chart dashboards that efficiently handle real-time data streams while maintaining high rendering performance.