Server-Side Chart Layout Engine for Web Application Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current charting technologies face performance issues when rendering complex charts in web applications, as they require significant network bandwidth and machine resources due to the need for local data processing and layout, leading to slow load and render times, especially with large datasets and complex features.
Innovation Solution
Implementing a server-side chart layout system where a layout engine generates a scene graph on the server, which is then transmitted to the client for rendering, allowing for efficient data transmission and minimizing client-side processing, enabling faster chart load and render performance while maintaining chart fidelity across different endpoints.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If chart layout is performed locally in the browser, then chart interactivity and responsiveness are improved, but network bandwidth usage and machine resource consumption increase significantly
Solution Approach 1:
The patent divides the charting system into two segments: server-side layout engine that performs complex computations, and client-side web player that handles rendering and interactivity. This segmentation allows the heavy computational burden to be offloaded to the server while maintaining local responsiveness.
Solution Approach 2:
The patent introduces a scene graph as an intermediary data structure that bridges the server-side layout engine and client-side web player. The scene graph contains normalized and annotated information that enables the client to render charts locally without requiring complex local processing, thus reducing machine resource consumption while maintaining interactivity.
2Adaptability or versatility
If complex chart features and large datasets are supported, then chart functionality and data capacity increase, but layout computation time and network bandwidth usage increase
Solution Approach 1:
The server-side layout engine performs layout computations in advance on the server before transmitting results to the client. This preliminary action on the server eliminates the need for time-consuming local layout computations in the browser, even for complex charts with large datasets.
Solution Approach 2:
The patent changes the parameter of where layout computation occurs from client-side to server-side. The layout engine generates a scene graph with normalized coordinates and pre-computed layout information, transforming the problem from requiring heavy client-side computation to simple client-side rendering based on pre-computed parameters.
3Quantity of substance
If more chart data points and elements are included, then data representation capability improves, but rendering performance and load time deteriorate
Solution Approach 1:
The patent creates a simplified copy of the chart data in the form of a scene graph that contains only the essential rendering information needed by the client. Instead of transmitting and processing all raw data points locally, the server generates a condensed scene graph with normalized coordinates that enables fast client-side rendering of even large datasets.
Data Source
AI summary
Server-side chart layout for web applications is provided. Output of a server-side layout engine is exposed on the web via a server-side web service and a client-side web player that communicates with the web service. The web player is operative to send chart definitions to the web service, and receive a scene graph of a resultant chart layout. The scene graph includes normalized and annotated information to draw the chart, animate transitions, implement interactivities, and provide standardized accessibility locally within a web client. Aspects enable chart fidelity across native and browser endpoints, and provide faster chart load and render performance that is unaffected by growth of data size or expansions in provided chart features.