WebGPU-based geographic vector data rendering method, storage medium, equipment and computer program product
By using WebGPU technology in geovector data rendering, and using binding groups and computing shaders to optimize data processing, the problem of slow rendering speed in traditional methods is solved, and efficient geovector data rendering is achieved, which is suitable for a variety of application scenarios.
Patent Information
- Application Number
- CN202411545434.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-11-01
- Publication Date
- 2024-12-03
- Estimated Expiration
- 2044-11-01
AI Technical Summary
Traditional geovector data rendering methods have problems such as slow rendering speed and performance bottlenecks when processing large-scale and high-complex geographic data, which is difficult to meet the needs of real-time applications.
Using a WebGPU-based approach, by creating and configuring the WebGPU context, obtaining and parsing geospatial information data, using binding group layout and computing shaders for data space description and rendering, reducing layout state switching overhead, and expanding GPU parallel computing capabilities.
It significantly improves the rendering speed and efficiency of geovector data, supports efficient management and loading of large-scale data, and is suitable for GIS, navigation systems and virtual reality fields.
Smart Images

Figure CN119067856A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of geographic information systems, and in particular to a geographic vector data rendering method, storage medium, device and computer program product based on WebGPU. Background Art
[0002] With the development of Geographic Information System (GIS) technology, geographic vector data is being used more and more widely. Traditional geographic vector data rendering methods mainly rely on CPU and WebGL technology. However, these technologies have problems such as slow rendering speed and performance bottleneck when processing large-scale and highly complex geographic data, making it difficult to meet the needs of real-time applications.
[0003] WebGPU is a next-generation graphics API that aims to provide more efficient hardware-accelerated graphics processing capabilities. Compared with WebGL, WebGPU has higher performance and a more flexible programming model, and can better utilize the computing power of modern GPUs. Therefore, the geographic vector data loading and rendering method based on WebGPU has important research value and application prospects.
[0004] At present, some research and applications have tried to use WebGPU for graphics rendering, but there is no mature solution for geographic vector data processing. Therefore, how to use WebGPU to achieve efficient rendering of geographic vector data is still a technical problem that needs to be solved urgently. Summary of the invention
[0005] In view of the problems existing in the prior art, the present invention provides a geographic vector data rendering method, storage medium, device and computer program product based on WebGPU, which can realize efficient geographic vector data processing and real-time rendering.
[0006] To achieve the above technical objectives, the present invention adopts the following technical solution: a geographic vector data rendering method based on WebGPU, comprising the following steps: Step 1. Create and configure the WebGPU context, configure the canvas size and canvas grid size, and write the canvas grid size to the uniform buffer. Step 2: Obtain each frame of geographic spatial information data to be rendered from GIS, convert it into geographic vector data, parse it, extract the vertex coordinates of the geographic vector data, and write it into the vertex buffer; Step 3: Create a data space according to the geographic vector data, use the data space to describe the vertex rendering state of the geographic vector data, and write it into a storage buffer; Step 4: Create a binding group layout for the uniform buffer and the storage buffer, create binding groups according to the binding group layout to mark different data spaces, and create a pipeline layout using the binding group layout. Step 5: For a certain frame of geographic vector data to be rendered, a compute shader is created according to the created pipeline layout, the compute shader configures the compute pipeline, and the compute pipeline and the corresponding binding group are used to create a compute channel for non-rendering tasks; Step 6: Create a rendering shader according to the created pipeline layout, configure the rendering pipeline by the rendering shader, use the vertex buffer and the rendering pipeline to configure the rendering channel, and render the geographic vector data to be rendered in the corresponding frame; Step 7: Repeat steps 5-6 until the rendering process of the geographic vector data to be rendered for the specified number of frames is completed.
[0007] Furthermore, step 2 includes the following sub-steps: Step 2.1, obtaining each frame of geospatial information data to be rendered from GIS, and converting the geospatial information data to be rendered into geographic vector data through AJAX request according to the unified positioning identifier of the geospatial information data to be rendered; Step 2.2, parsing the geographic vector data to extract vertex coordinates of the geographic vector data; Step 2.3: Package the extracted vertex coordinates into a vertex array through the typed array Float32Array in JavaScript and write it into the vertex buffer.
[0008] Furthermore, the specific process of step 3 is: the vertex array corresponding to the geographic vector data is split into triangle units in turn using a triangulation algorithm, and a data space equal to the number of frames of geographic spatial information data to be rendered is created, the array length in each data space is equal to the number of triangle units corresponding to each frame of geographic vector data, and each number stored in each array is used to describe the rendering status of the corresponding triangle unit, and all arrays are written to the storage buffer.
[0009] Furthermore, the specific process of creating a compute shader in step 5 is: use the compute shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the compute shader annotation @binding(j) to access the j-th number in the corresponding data space, use the compute shader annotation @compute to mark the calculation function of the compute shader, use the compute shader annotation @workgroup_size to describe the calculation group size in the compute shader, and obtain the compute shader for the geographic vector data to be rendered in the i-th frame.
[0010] Furthermore, the specific process of creating a rendering shader in step 6 is: use the rendering shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the rendering shader annotation @binding(j) to access the j-th number in the corresponding data space, use the rendering shader annotation @vertex to mark the vertex function of the rendering shader, use the rendering shader annotation @location(j) to obtain the vertex array corresponding to the j-th number in the corresponding data space, use the rendering shader annotation @fragment to mark the fragment function of the rendering shader, and obtain the rendering shader for the geographic vector data to be rendered in the i-th frame.
[0011] Furthermore, the specific process of creating the rendering pipeline in step 6 is: configuring the vertices in the rendering pipeline according to the vertex function of the rendering shader, and configuring the fragments in the rendering pipeline according to the fragment function of the rendering shader.
[0012] Furthermore, the specific process of creating a rendering channel in step 6 is: by creating a vertex buffer layout in the rendering pipeline, define a vertex data layout for the vertex buffer that matches the vertex data layout used in the rendering shader, obtain the canvas configured in step 1 by calling the context.getCurrentTexture().createView() function, configure the rendering channel on the canvas according to the vertex buffer layout using the vertex buffer and the rendering pipeline, and obtain the vertex coordinates of the geographic vector data to be rendered in the i-th frame for rendering.
[0013] Furthermore, the present invention also provides a computer-readable storage medium storing a computer program, wherein the computer program enables a computer to execute the WebGPU-based geographic vector data rendering method.
[0014] Furthermore, the present invention also provides an electronic device, comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the WebGPU-based geographic vector data rendering method is implemented.
[0015] Furthermore, the present invention also provides a computer program product, including a computer program, which implements the WebGPU-based geographic vector data rendering method when executed by a processor.
[0016] Compared with the prior art, the present invention has the following beneficial effects: The geographic vector data rendering method based on WebGPU of the present invention makes full use of the high-performance graphics processing capability of WebGPU, uses binding groups to create pipeline layouts before rendering geographic vector data, reduces the layout state switching overhead during rendering, and WebGPU supports compute shaders, which can further expand the scope of use of GPU parallel computing capabilities, thereby significantly improving the rendering speed and efficiency of geographic vector data; The geographic vector data rendering method based on WebGPU of the present invention describes the vertex rendering state of geographic vector data by creating a data space, divides large-scale geographic vector data into blocks according to time sequence, and marks different data spaces by binding groups, thereby establishing an efficient index structure, realizing efficient management of large-scale geographic vector data, and accelerating the loading and rendering process of geographic vector data; The geographic vector data rendering method based on WebGPU of the present invention can support various geographic vector data formats and has broad application prospects in the fields of GIS, navigation systems and virtual reality. BRIEF DESCRIPTION OF THE DRAWINGS
[0017] Figure 1 This is a specific flow chart of the geographic vector data rendering method based on WebGPU of the present invention. DETAILED DESCRIPTION
[0018] The technical solution of the present invention is further explained below in conjunction with the accompanying drawings.
[0019] like Figure 1 The following is a specific flow chart of the geographic vector data rendering method based on WebGPU of the present invention, which specifically includes the following steps: Step 1: Initialize WebGPU, which includes the following steps: Step 1.1. Check whether the browser environment has navigator.gpu. If not, change the browser to a browser that supports WebGPU and check whether the GPU provides an adapter navigator.gpu.requestAdapter(). If not, the device needs to be configured with a discrete graphics card. Step 1.2, obtain the GPU adapter through adapter.requestDevice(), obtain the device from the adapter, and all subsequent steps require obtaining the corresponding interface from the device; Step 1.3, configure the WebGPU context and canvas. Specifically, create a canvas, pick up the WebGPU context as "webgpu", get the general optimal configuration navigator.gpu.getPreferredCanvasFormat(), and use the optimal configuration and device configuration canvas.
[0020] Step 2: Obtain each frame of geospatial information data to be rendered, convert it into geovector data, parse it, and extract the vertex coordinates of the geovector data. It can support various geovector data formats and has broad application prospects in GIS, navigation systems, virtual reality and other fields. It specifically includes the following sub-steps: Step 2.1, each frame of geospatial information data to be rendered can be obtained from GIS, and the geospatial information data to be rendered can be converted into geographic vector data through AJAX request according to the unified positioning identifier of the geospatial information data to be rendered; Step 2.2, parsing the geographic vector data to extract the vertex coordinates of the geographic vector data; Step 2.3: Package the extracted vertex coordinates into a vertex array through the Float32Array in the typed array TypeArray in JavaScript to adapt to the digital storage format required by the GPU.
[0021] Step 3: Data preprocessing, including the following steps: Step 3.1, create a data space according to the geographic vector data, use the data space to describe the vertex rendering state of the geographic vector data, so as to divide the large-scale geographic vector data into blocks according to the time sequence, realize the efficient management of large-scale geographic vector data, and speed up the subsequent geographic vector data rendering process; specifically, The vertex arrays corresponding to the geographic vector data are split into triangle units using a triangulation algorithm. The triangulation algorithm can use the Ear Clipping Method splitting logic to traverse the polygons formed by the vertex arrays, find the triangle units formed by the convex vertices, and remove the triangle units from the polygons in turn until only three vertex arrays are left in the polygon. Create a data space with the same number of frames of geographic spatial information data to be rendered. The length of the array in each data space is equal to the number of triangle units corresponding to each frame of geographic vector data, and the number stored in each bit of each array is used to describe the rendering status of the corresponding triangle unit. 1 can be used to indicate that the triangle unit needs to be drawn, and 0 can be used to indicate that the triangle unit does not need to be drawn. This ensures that the rendering status of the triangle unit can be accessed every time to guide the rendering process and improve rendering efficiency.
[0022] Step 3.2, configure the canvas grid size. Generally, the canvas grid size is set to 128 and the canvas size is 128×128. Since the default origin of the webGPU canvas is at the center, the corresponding coordinates of the upper right corner of the canvas are (64, 64) and the corresponding coordinates of the lower left corner are (-64, -64).
[0023] Step 4: Create WebGPU resources, including the following process: Step 4.1. Create a vertex buffer by calling the device.createbuffer function and configuring the usage parameter in the object parameter to GPUBufferUsage.VERTEX, and write the vertex array into the vertex buffer. The vertex buffer is specifically used to store vertex coordinate information, which can define the shape of the geometry in data graphics rendering. Step 4.2, create a uniform buffer by calling the device.createbuffer function and configuring the usage parameter in the object parameter to GPUBufferUsage.UNIFORM, and write the canvas grid size to the uniform buffer. The data in the uniform buffer is used every time you draw and usually does not change; Step 4.3, create a storage buffer by calling the device.createbuffer function and configuring the usage parameter in the object parameter to GPUBufferUsage.STORAGE, and write all arrays to the storage buffer. The storage buffer stores dynamic data on whether the triangle unit is rendered, which can improve the efficiency of parallel computing.
[0024] Step 5: Configure WebGPU resources, including the following process: Step 5.1. After writing the data space into the storage buffer, it is still just simple binary data. You need to configure the vertex buffer layout for the vertex buffer and describe to the computer how to read the entire binary data. Specifically, you need to describe the byte size of the vertex array corresponding to each number in the data space, how many numbers in the vertex array represent a vertex coordinate, the storage format of the vertex array, and which number in the data space to start reading from; Step 5.2, call the device.createBindGroupLayout method to create a binding group layout for the uniform buffer and storage buffer, where device is a GPU device object. Create a binding group according to the binding group layout to manage the storage buffer. Use the binding group to mark different data spaces, establish an efficient index structure, and achieve fast loading and rendering of specified geographic vector data. Step 5.3: For a certain frame of geographic vector data to be rendered, create a compute shader according to the created pipeline layout. Specifically, use the compute shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the compute shader annotation @binding(j) to access the j-th number in the corresponding data space, use the compute shader annotation @compute to mark the calculation function of the compute shader, and use the compute shader annotation @workgroup_size to describe the calculation group size in the compute shader to obtain the compute shader of the i-th frame of geographic vector data to be rendered. WebGPU natively supports compute shaders and can efficiently utilize the parallel computing capabilities of GPU.
[0025] Step 5.4: For a certain frame of geographic vector data to be rendered, create a rendering shader according to the created pipeline layout. Specifically, use the rendering shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the rendering shader annotation @binding(j) to access the j-th number in the corresponding data space, use the rendering shader annotation @vertex to mark the vertex function of the rendering shader, use the rendering shader annotation @location(j) to obtain the vertex array corresponding to the j-th number in the corresponding data space, use the rendering shader annotation @fragment to mark the fragment function of the rendering shader, and obtain the rendering shader of the geographic vector data to be rendered in the i-th frame. After the calculation shader is processed, the rendering shader obtains the geographic vector data to be rendered through the annotation, avoiding frequent data state switching in the rendering shader and reducing performance overhead.
[0026] Step 6: Create a computing pipeline and a rendering pipeline, including the following process: Step 6.1, call the device.createPipelineLayout() function to create a pipeline layout for controlling how the compute shader and render shader access GPU resources; Step 6.2, call device.createComputePipeline() function to configure the compute pipeline according to the compute shader and pipeline layout. The compute pipeline flexibly binds GPU resources through the pipeline layout, avoids frequent state switching of the pipeline layout, and reduces performance overhead; Step 6.3. Call the device.createRenderPipeline() function to configure the rendering pipeline according to the rendering shader and pipeline layout. Specifically, configure the vertices in the rendering pipeline according to the vertex function of the rendering shader, configure the fragments in the rendering pipeline according to the fragment function of the rendering shader, use the vertex buffer layout created in step 5.1 as the vertex buffer layout of the rendering pipeline, define the vertex buffer to match the vertex data layout used in the rendering shader, and set the output position of the fragment.
[0027] Step 7: Create a calculation channel and a rendering channel, including the following process: Step 7.1, create a command editor: device.createCommandEncoder(); Step 7.2, create a computing channel through the beginComputedPass function of the command encoder, use the computing pipeline and the corresponding binding group to configure the computing channel, assign work items to the computing channel, and submit it to the GPU for execution. In terms of configuration, the computing channel does not need to rely on the rendering channel and can flexibly handle non-rendering tasks; Step 7.3, create a rendering channel through the beginRenderPass function of the command encoder, obtain the canvas configured in step 1 by calling the context.getCurrentTexture().createView() function, configure the rendering channel on the canvas using the vertex buffer and rendering pipeline, obtain the vertex coordinates of the geographic vector data to be rendered in the i-th frame for rendering, and the rendering channel can output the results to multiple target textures, allowing for more complex visual effects and reducing multiple drawing calls; and set the number of drawing points and the number of drawing times of the rendering channel according to the actual situation, and submit drawing instructions to the GPU; Step 8: Update in a loop. Specifically, through the browser's requestAnimationFrame or by specifying the number of frames, repeat steps 5.3 to 7.4 to complete the dynamic rendering process of the geographic vector data.
[0028] The geographic vector data rendering method based on WebGPU of the present invention utilizes WebGPU technology to realize the rendering of geographic vector data, fully utilizes the high-performance graphics processing capability of WebGPU, uses binding groups to create pipeline layout before rendering geographic vector data, reduces the layout state switching overhead during rendering, and makes WebGPU process pixels 3.5 times faster than traditional WebGL. In addition, WebGPU supports compute shaders, which can further expand the scope of use of GPU parallel computing capabilities, thereby significantly improving the rendering speed and efficiency of geographic vector data.
[0029] In a technical solution of the present invention, a computer-readable storage medium is also provided, storing a computer program, wherein the computer program enables a computer to execute the WebGPU-based geographic vector data rendering method.
[0030] In a technical solution of the present invention, an electronic device is also provided, including: a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the WebGPU-based geographic vector data rendering method is implemented.
[0031] In a technical solution of the present invention, a computer program product is also provided, including a computer program, and when the computer program is executed by a processor, the WebGPU-based geographic vector data rendering method is implemented.
[0032] In a technical solution of the present invention, a geographic vector data rendering system based on WebGPU is also provided, comprising: a WebGPU configuration module, a data parsing module, a data space, a binding module, a non-rendering task execution module and a rendering module; The WebGPU configuration module is used to create and configure the WebGPU context, configure the canvas size and canvas grid size, and write the canvas grid size to the uniform buffer; The data parsing module is used to convert the geospatial information data to be rendered into geovector data, parse and extract the vertex coordinates of the geovector data, and write them into the vertex buffer; The data space is used to describe the vertex rendering state of geographic vector data and write it into the storage buffer; The binding module creates binding group layouts for uniform buffers and storage buffers, creates binding groups based on the binding group layouts to mark different data spaces, and creates pipeline layouts using the binding group layouts. The non-rendering task execution module is used to create a computing shader for the geographic vector data to be rendered according to the created pipeline layout, configure the computing pipeline by the computing shader, and use the computing pipeline and the corresponding binding group to create a computing channel for the non-rendering task; The rendering module is used to create a rendering shader for the geographic vector data to be rendered according to the created pipeline layout, configure the rendering pipeline by the rendering shader, create a vertex buffer layout according to the vertex buffer in the rendering pipeline, and obtain vertex coordinates according to the vertex buffer layout to complete the rendering of the geographic vector data to be rendered.
[0033] In the embodiments disclosed in the present application, the computer storage medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, device, or apparatus. The computer storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or equipment, or any suitable combination of the foregoing. More specific examples of computer storage media may include electrical connections based on one or more lines, portable computer disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), optical fibers, portable compact disk read-only memories (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.
[0034] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in this application can be implemented in electronic hardware or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.
[0035] The above are only preferred embodiments of the present invention, and the protection scope of the present invention is not limited to the above embodiments. All technical solutions under the concept of the present invention belong to the protection scope of the present invention. It should be pointed out that for ordinary technicians in this technical field, some improvements and modifications without departing from the principle of the present invention should be regarded as the protection scope of the present invention.
Claims
1. A geographic vector data rendering method based on WebGPU, characterized in that: The steps include: Step 1. Create and configure the WebGPU context, configure the canvas size and canvas grid size, and write the canvas grid size to the uniform buffer. Step 2: Obtain each frame of geographic spatial information data to be rendered, convert it into geographic vector data, parse it, extract the vertex coordinates of the geographic vector data, and write it into the vertex buffer; Step 3: Create a data space according to the geographic vector data, use the data space to describe the vertex rendering state of the geographic vector data, and write it into a storage buffer; Step 4: Create a binding group layout for the uniform buffer and the storage buffer, create binding groups according to the binding group layout to mark different data spaces, and create a pipeline layout using the binding group layout. Step 5: For a certain frame of geographic vector data to be rendered, a compute shader is created according to the created pipeline layout, the compute shader configures the compute pipeline, and the compute pipeline and the corresponding binding group are used to create a compute channel for non-rendering tasks; Step 6: Create a rendering shader according to the created pipeline layout, configure the rendering pipeline by the rendering shader, use the vertex buffer and the rendering pipeline to configure the rendering channel, and render the geographic vector data to be rendered in the corresponding frame; Step 7: Repeat steps 5-6 until the rendering process of the geographic vector data to be rendered for the specified number of frames is completed.
2. According to the WebGPU-based geographic vector data rendering method of claim 1, it is characterized in that: Step 2 includes the following sub-steps: Step 2.1, obtaining each frame of geospatial information data to be rendered, and converting the geospatial information data to be rendered into geographic vector data through an AJAX request according to a unified positioning identifier of the geospatial information data to be rendered; Step 2.2, parsing the geographic vector data to extract vertex coordinates of the geographic vector data; Step 2.3: Package the extracted vertex coordinates into a vertex array through the typed array Float32Array in JavaScript and write it into the vertex buffer.
3. According to the WebGPU-based geographic vector data rendering method of claim 2, it is characterized in that: The specific process of step 3 is: split the vertex array corresponding to the geographic vector data into triangle units in turn using a triangulation algorithm, and create a data space with the same number of frames of geographic spatial information data to be rendered. The array length in each data space is equal to the number of triangle units corresponding to each frame of geographic vector data, and each number stored in each array is used to describe the rendering status of the corresponding triangle unit, and all arrays are written into the storage buffer.
4. According to the WebGPU-based geographic vector data rendering method of claim 3, it is characterized in that: The specific process of creating a compute shader in step 5 is: use the compute shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the compute shader annotation @binding(j) to access the j-th number in the corresponding data space, use the compute shader annotation @compute to mark the calculation function of the compute shader, use the compute shader annotation @workgroup_size to describe the calculation group size in the compute shader, and obtain the compute shader for the geographic vector data to be rendered in the i-th frame.
5. According to the WebGPU-based geographic vector data rendering method of claim 4, it is characterized in that: The specific process of creating a rendering shader in step 6 is: use the rendering shader annotation @group(i) to access the data space of the binding group corresponding to the geographic vector data to be rendered in the i-th frame, use the rendering shader annotation @binding(j) to access the j-th number in the corresponding data space, use the rendering shader annotation @vertex to mark the vertex function of the rendering shader, use the rendering shader annotation @location(j) to obtain the vertex array corresponding to the j-th number in the corresponding data space, use the rendering shader annotation @fragment to mark the fragment function of the rendering shader, and obtain the rendering shader for the geographic vector data to be rendered in the i-th frame.
6. The method for rendering geographic vector data based on WebGPU according to claim 5, characterized in that: The specific process of creating the rendering pipeline in step 6 is: configuring the vertices in the rendering pipeline according to the vertex function of the rendering shader, and configuring the fragments in the rendering pipeline according to the fragment function of the rendering shader.
7. The method for rendering geographic vector data based on WebGPU according to claim 6, characterized in that: The specific process of creating a rendering channel in step 6 is: by creating a vertex buffer layout in the rendering pipeline, define a vertex data layout for the vertex buffer that matches the vertex data layout used in the rendering shader, obtain the canvas configured in step 1 by calling the context.getCurrentTexture().createView() function, configure the rendering channel on the canvas according to the vertex buffer layout using the vertex buffer and the rendering pipeline, and obtain the vertex coordinates of the geographic vector data to be rendered in the i-th frame for rendering.
8. A computer-readable storage medium storing a computer program, characterized in that: The computer program enables a computer to execute the WebGPU-based geographic vector data rendering method as described in any one of claims 1 to 7.
9. An electronic device, characterized in that: include: A memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the method for rendering geographic vector data based on WebGPU as described in any one of claims 1 to 7 is implemented.
10. A computer program product, comprising a computer program, characterized in that When the computer program is executed by a processor, the WebGPU-based geographic vector data rendering method described in any one of claims 1 to 7 is implemented.
Citation Information
Patent Citations
Real-time refining three-dimensional modeling and rendering method for massive road networks
CN106127855A
High-performance rendering method and device for urban information model and storage medium
CN110706341A
Virtual terrain rendering method for carrying out resource dynamic processing and caching based on GPU
CN111563948A
Three-dimensional rendering method and device of geographic information system, equipment and storage medium
CN113379886A
Three-dimensional digital earth construction method for avionics display and control
CN113593028A
Cited By
Web large language model reasoning acceleration optimization method and device based on WebGPU
CN119338016A
Web GPU-based Web large language model reasoning acceleration optimization method and device
CN119338016B
WebGPU-based three-dimensional model loading method and system
CN119359884A
Data lightweight display method and device fused with GIS spatial analysis capability
CN119537467A
Front-end graph rendering system and method based on WebGPU
CN121169662A
