Infrastructure Geometry Tiling for Polyline and Edge Rendering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing techniques for converting infrastructure model geometry to a format suitable for display on client devices are inefficient, particularly in terms of processing and storage resource utilization, especially when handling polylines and edges, due to the limitations of GL Transmission Format (gITF) and the redundancy of vertex data.
Innovation Solution
An architectural split between frontend and backend applications allows CPU-intensive operations like polyline tessellation to be performed remotely on robust hardware, using a multi-threaded environment, and data is combined into a single lookup table for efficient vertex representation, minimizing duplication and optimizing storage consumption.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If gITF standard format is used to represent meshes and tiles, then data structure is simple and standardized, but it cannot produce certain primitives like polylines and edges
Solution Approach 1:
The patent segments the geometry representation into two distinct parts: mesh data stored in standard gITF format and polyline/edge data stored separately in a custom format. This allows the system to maintain compatibility with gITF while adding support for additional primitive types without modifying the core gITF structure.
Solution Approach 2:
The patent merges the advantages of standardized gITF format with custom polyline/edge representation into a unified tile structure. The tile format combines mesh data (vertices, indices, normals) with polyline data (vertex positions, line styles) and edge data (mesh edge definitions), allowing all primitive types to coexist in a single standardized tile structure.
2Ease of operation
If polylines and edges are tessellated on client devices, then display flexibility is improved, but processing resources are burdened
Solution Approach 1:
The patent performs preliminary tessellation of polylines and edges on the server side before generating tiles. Complex geometric operations such as converting polylines to polylines with vertices, extruding polylines to create 3D geometry, and tessellating edges are completed in advance during tile generation, so that client devices only need to render pre-processed geometry.
Solution Approach 2:
The server acts as an intermediary that performs CPU-intensive tessellation operations and converts complex geometry into simplified tile-ready formats. The server mediates between the raw infrastructure model data and the client device, preprocessing the data to reduce the computational burden on client devices while maintaining display flexibility.
3Adaptability or versatility
If gITF structure is modified to store polylines with repeated vertex data, then polyline representation is enabled, but storage efficiency deteriorates
Solution Approach 1:
Instead of copying vertex data multiple times in parallel arrays, the patent creates a single copy of vertex data in a dedicated polyline vertex array, then references it multiple times through indexing. Each polyline segment references vertices from this shared array, eliminating redundant data storage while enabling full polyline representation capability.
Solution Approach 2:
The patent creates a universal vertex array that serves multiple purposes: it stores vertices for meshes, polylines, and edge geometry simultaneously. This single vertex array is referenced by all geometry types, allowing the system to represent diverse primitive types efficiently without duplicating vertex data across multiple specialized arrays.
4Adaptability or versatility
If infrastructure models are maintained in unified digital twin format, then data silos are eliminated, but processing and display complexity increases
Solution Approach 1:
The patent segments the unified digital twin model into discrete tiles that can be independently processed and displayed. Each tile contains self-contained geometry data (meshes, polylines, edges) for a specific spatial region, allowing the large unified model to be broken down into manageable chunks that can be processed separately by client devices.
Solution Approach 2:
The system performs preliminary processing of the unified digital twin model on the server side, converting the entire model into tile format with all necessary geometry conversions, tessellations, and optimizations completed in advance. This preliminary action transforms the complex unified model into a structured tile hierarchy that is easier to process and display on client devices.
Data Source
Figure 1A
Figure 1B
Figure 2
AI summary
In example embodiments, techniques are provided for converting geometry of an infrastructure model represented as high-level geometric primitives having a given symbology to low-level primitives, and encoding these low-level primitives into tile contents suited for transmission, and ultimately display upon, on a client device. An architectural split between frontend applications and backend applications may allow conversion of the high level primitives to be performed remote from the client devices by backend applications. Backend applications may be executed on robust hardware devices that execute software in a multi-threaded environment on powerful CPUs. By performing CPU-intensive operations on backend applications, frontend applications on client devices may be required to do little more than submit low-level primitives for rendering on their GPU.