A method for real-time visualization of massive point cloud with uniform sampling

Abstract

The application discloses a kind of massive point cloud real-time visualization methods of uniform sampling, it is related to point cloud visualization technical field, comprising: original point cloud data is carried out multithreaded Morden coding, obtains multiple binary segment files;Multiple binary segment files are merged, and target file is obtained;Point cloud data in target file is carried out hierarchical uniform sampling, and sampling point cloud data is obtained;Based on sampling point cloud data and target file, LOD three-dimensional model is constructed;Each level and its corresponding focal length are stored in array;Utilize the containment or intersection test of frustum and node bounding box, and the LOD node that meets the condition and level is less than or equal to target level is added to loading list;Through double-buffering FBO, data is switched in real time and uploaded to GPU.The application solves the technical problem that prior art has not formed a complete technical chain of general terminal, throughout import, index, load, rendering.

Description

Technical Field

[0001] This invention belongs to the field of point cloud visualization technology, specifically relating to a method for real-time visualization of massive point clouds with uniform sampling. Background Technology

[0002] Currently, the output of 3D point cloud data is growing exponentially. For example, automotive-grade LiDAR can output 2 million points per second, and a single urban oblique photogrammetry project can easily exceed 10 billion points; in recent years, the global point cloud data volume will reach 73 ZB. Driven by applications such as smart cities, autonomous driving, digital cultural heritage protection, and metaverse, the industry's demand for "smooth browsing of massive point clouds on low-cost terminals" is becoming increasingly urgent. However, limited by CPU, video memory, and mechanical hard drive random I / O bottlenecks, existing publicly available technologies cannot simultaneously meet the requirements of "minute-level import + accurate LOD + stable 60FPS rendering" in a typical PC environment with 8GB RAM and 6GB VRAM.

[0003] Several patents have attempted to alleviate these contradictions: US11010930B2 uses a dynamic ROI switching approach, but its octree is still built offline using a serial script; CN109345619A stores point cloud slices as multi-level files, but fails to consider the coarse granularity of loading caused by camera focal length; EP3474514A1 utilizes cloud snapshot lazy loading, but the client still requires high memory; authorized patents (CN111882657B, CN111402429B) focus on scale calibration or network transmission protocols, paying insufficient attention to real-time rendering on low-end hardware. Commonly used tools in the industry are also constrained by these bottlenecks: PotreeConverter's single-threaded import speed is only 3-4 million points / minute; CloudCompare can only open a maximum of 100 million points with 8GB RAM; Cesium 3D iles can only smoothly display 3 billion points even in an RX 3060 environment. It is evident that most current patents and products focus on offline processing or high-end hardware scenarios, and a complete technology chain spanning "import-index-load-rendering" has not yet been formed for ordinary terminals. Existing point cloud visualization systems are mainly geared towards high-performance workstations or servers. In general PC environments with limited hardware and software resources, the following technical bottlenecks often prevent them from meeting the real-time interactive requirements: (1) single-threaded preprocessing leads to import time consumption; (2) a large amount of random I / O between disk and memory; (3) uneven point spacing in multi-level LOD; (4) decoupling of loading granularity from camera parameters; (5) GPU data replacement blocks the rendering pipeline. Summary of the Invention

[0004] The technical problem to be solved by this invention is to provide a method for real-time visualization of massive point clouds with uniform sampling, so as to solve some of the above-mentioned technical problems.

[0005] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0006] A method for real-time visualization of massive point clouds with uniform sampling includes the following steps:

[0007] S1. Obtain raw point cloud data; perform multi-threaded Morton encoding on the raw point cloud data to obtain multiple binary segment files;

[0008] S2. The k-way merge algorithm is used to merge multiple binary segment files to obtain the target file;

[0009] S3. Perform hierarchical uniform sampling on the point cloud data in the target file to obtain sampled point cloud data;

[0010] S4. Construct the LOD 3D model: Group the sampled point cloud data into the corresponding LOD nodes according to the corresponding level, and record the average point distance and node bounding box of the sampled point cloud data in the target file in each LOD node.

[0011] S5. Based on the mapping relationship between focal length and average point distance, each average point distance corresponds to a level, and each level and the focal length corresponding to each level are stored in an array.

[0012] S6. Use the view frustum and node bounding box to perform containment or intersection tests, and add LOD nodes that meet the conditions and whose level is less than or equal to the target level to the loading list;

[0013] S7: The background thread asynchronously reads the sampling point cloud data corresponding to the LOD node in the loading list into the CPU memory, and then switches and uploads the data to the GPU in real time through a double-buffered FBO.

[0014] Furthermore, S1 includes:

[0015] S11. Setting parameters: Set the size of the point cloud block according to the hardware memory, the bit width of the Morton coding is 21 bits, the preset level is 8 layers, and the circular buffer threshold is 1 million points.

[0016] S12. Based on the number of CPU cores in the computer, allocate the same number of threads as the number of CPU cores and allocate an independent expandable circular buffer for each thread;

[0017] S13. Load the original point cloud file into memory, divide all the original point cloud data in the original point cloud file into multiple point cloud blocks according to the size of the point cloud blocks, and distribute the multiple point cloud blocks to a multi-threaded work queue.

[0018] S14. Each thread uses the Morton coding algorithm to divide the current point cloud block into blocks at all levels, resulting in multiple Morton point cloud blocks at all levels. Each Morton point cloud block has a Morton code. The multiple Morton point cloud blocks are stored in an expandable circular buffer. When the total number of point clouds corresponding to the multiple Morton point cloud blocks in the expandable circular buffer reaches the circular buffer threshold, the thread triggers a sequential write to disk, sorts the point clouds in the expandable circular buffer according to the order of the Morton codes from smallest to largest, and saves the sorted point clouds to binary segment files. After all threads have processed all point cloud blocks, multiple binary segment files are obtained.

[0019] Furthermore, S2 includes:

[0020] S21. Read the Morton point cloud block information in each binary segment file one by one. The Morton point cloud block information includes: level, Morton code, total number of points, and offset of each point in the binary segment file.

[0021] S22. Count the total number of point clouds corresponding to the Morton point cloud blocks under the same level, and calculate the overall size required for the target file based on the total number of point clouds;

[0022] S23. Reserve a contiguous storage area in the target file for each Morton point cloud block at the same level, and record the starting byte position of each segment;

[0023] S24. Based on the starting byte position of each segment, calculate the final write address of each Morton point cloud block in the target file, and at the same time calculate the cumulative offset within the segment;

[0024] S25. Generate a newly named binary segment file as the target file;

[0025] S26. Copy the data of each Morton point cloud block to the target file simultaneously according to the starting byte position and the final write address;

[0026] S27. Write an index record for each segment. The index record includes: level, Morton code, segment start address, and total number of point clouds. Calculate the sum of all index records, the total number of points in all index records, and the maximum and minimum values ​​of the X, Y, and Z coordinates of the total point cloud in all index records to obtain statistical information. Update the statistical information to the header information of the target file.

[0027] Furthermore, S3 includes:

[0028] S31. For each Morton point cloud block in the target file, calculate the voxel side length and diagonal length of the point cloud data based on the bounding box and target level.

[0029] S32. Construct a first set for recording occupied voxels and a second set for recording the coordinate information of the first reserved point in the occupied voxels. Both the first set and the second set reserve capacity by dividing the number of input points by 8.

[0030] S33. Pre-list the coordinate offsets of 27 voxels consisting of 1 voxel and 26 neighboring voxels of the voxel;

[0031] S34. Perform the following operations for each input point cloud: locate the voxel key of the current point cloud; if the voxel is already occupied, skip the current point; if the voxel is not occupied, check if there is a reserved point among the 26 neighboring voxels and the distance is less than the voxel diagonal; if there is a reserved point and the distance is less than the voxel diagonal, skip the current point; if the current point is not skipped, write the current point into the second set and record the mapping from the voxel key to the coordinates of the current point, mark the voxel as occupied in the first set, and attach the true level and average point distance;

[0032] S35. Output the second set and trim it to the reserved capacity to obtain the sampled point cloud data.

[0033] Furthermore, in S31, the formula for calculating the voxel side length s(L) is:

[0034] ;

[0035] Where L is the target level and L0 is the length of one side of the bounding box.

[0036] Furthermore, in S6, "meeting the conditions" means that a Morton point cloud block simultaneously meets the following two conditions:

[0037] Bounding box condition: A Morton point cloud block has eight vertices, and one vertex is inside the bounding box;

[0038] Angle condition: A Morton point cloud patch has eight vertices, one of which is inside the view frustum. The vertex inside the view frustum satisfies the following formula:

[0039] ;

[0040] Where a is the vector of the line connecting the camera center to the observation center, b is the vector of the line connecting the camera center to the vertex, and FOV is the field of view angle.

[0041] Furthermore, in S5, the mapping relationship between focal length and average point distance is as follows:

[0042] ;

[0043] in, Focal length The average point distance, From the perspective of This represents the number of pixels on the vertical tangent line of the screen within the viewpoint's field of view.

[0044] Furthermore, S7 includes: a background thread asynchronously reads the sampled point cloud data corresponding to the LOD nodes in the loading list into the CPU memory; the main thread loads the sampled point cloud data in the CPU memory into the VBO through OpenGL API functions; the data in the VBO is drawn offline into the FBO through OpenGL API functions; during the display process, OpenGL operates the default buffer to draw the data in the FBO into the default buffer for rendering.

[0045] Compared with the prior art, the present invention has the following beneficial effects:

[0046] This invention is scientifically sound and easy to use. It addresses the slow import speed of existing technologies by using multi-threaded Morton encoding and threshold disk writing to accelerate offline sorting. It maintains a multiplicative increase in LOD point spacing through hierarchical uniform sampling technology, avoiding scaling flicker. It precisely limits video memory and bandwidth through focal length-hierarchy mapping and dual-threshold frustum clipping. It solves the GPU-CPU synchronization blocking problem through dual-buffered FBO hot-switching, forming a complete technology chain for ordinary terminals, spanning "import-index-load-rendering". Real-world testing shows that 10 billion points can be imported within 2 hours on a typical laptop (8GB RAM, GX1660 6GB), and can be smoothly browsed at a stable 60FPS frame rate. This surpasses the technical limits of existing patents and tools, providing a practical solution for lightweight applications of massive point clouds. Attached Figure Description

[0047] Figure 1 This is a flowchart of the steps of the present invention. Detailed Implementation

[0048] Terminology Explanation:

[0049] K-way merge sort is an extended merge sort algorithm;

[0050] LOD is a method of creating multiple models of the same object with different levels of detail;

[0051] CPU stands for Central Processing Unit;

[0052] GPU stands for Graphics Processing Unit;

[0053] OpenGL is a cross-programming language, cross-operating system application programming interface for 2D and 3D graphics rendering.

[0054] API stands for Application Programming Interface;

[0055] VBO is a video memory area in OpenGL used to store vertex data;

[0056] An FBO is an object created in OpenGL that simulates the functionality and structure of the default frame buffer.

[0057] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are merely some embodiments of this invention, and not all embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0058] In the description of this invention, it should be noted that the terms "center," "upper," "lower," "left," "right," "vertical," "horizontal," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are used only for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on the invention. Furthermore, the terms "first," "second," and "third" are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0059] In the description of this invention, it should be noted that, unless otherwise explicitly specified and limited, the terms "installation," "connection," and "linking" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; of course, they can also refer to a mechanical connection or an electrical connection; furthermore, they can refer to a direct connection, an indirect connection through an intermediate medium, or a connection within two components. Those skilled in the art can understand the specific meaning of the above terms in this invention according to the specific circumstances.

[0060] like Figure 1 As shown, the present invention provides a method for real-time visualization of massive point clouds with uniform sampling, comprising the following steps:

[0061] S1. Obtain raw point cloud data; perform multi-threaded Morton encoding on the raw point cloud data to obtain multiple binary segment files;

[0062] S2. The k-way merge algorithm is used to merge multiple binary segment files to obtain the target file;

[0063] S3. Perform hierarchical uniform sampling on the point cloud data in the target file to obtain sampled point cloud data;

[0064] S4. Construct the LOD 3D model: Group the sampled point cloud data into the corresponding LOD nodes according to the corresponding level, and record the average point distance and node bounding box of the sampled point cloud data in the target file in each LOD node.

[0065] S5. Based on the mapping relationship between focal length and average point distance, each average point distance corresponds to a level, and each level and the focal length corresponding to each level are stored in an array.

[0066] S6. Use the view frustum and node bounding box to perform containment or intersection tests, and add LOD nodes that meet the conditions and whose level is less than or equal to the target level to the loading list;

[0067] S7: The background thread asynchronously reads the sampling point cloud data corresponding to the LOD node in the loading list into the CPU memory, and then switches and uploads the data to the GPU in real time through a double-buffered FBO.

[0068] This embodiment solves the problem of slow import speed in existing technologies by using multi-threaded Morton encoding to divide the raw point cloud data into multiple parallel blocks; it maintains the LOD point distance by using hierarchical uniform sampling technology to avoid scaling flicker; it precisely limits video memory and bandwidth by using focal length and hierarchical mapping and dual-threshold frustum clipping; and it solves the GPU-CPU synchronization blocking problem by using dual-buffered FBO hot switching. This embodiment addresses the fact that existing technologies have not yet formed a complete technology chain for ordinary terminals that runs through import, indexing, loading, and rendering.

[0069] In some embodiments, S1 includes:

[0070] S11. Setting parameters: Set the size of the point cloud block according to the hardware memory, the bit width of the Morton coding is 21 bits, the preset level is 8 layers, and the circular buffer threshold is 1 million points.

[0071] S12. Based on the number of CPU cores in the computer, allocate the same number of threads as the number of CPU cores and allocate an independent expandable circular buffer for each thread;

[0072] S13. Load the original point cloud file into memory, divide all the original point cloud data in the original point cloud file into multiple point cloud blocks according to the size of the point cloud blocks, and distribute the multiple point cloud blocks to a multi-threaded work queue.

[0073] S14. Each thread uses the Morton coding algorithm to divide the current point cloud block into blocks at all levels, resulting in multiple Morton point cloud blocks at all levels. Each Morton point cloud block has a Morton code. The multiple Morton point cloud blocks are stored in an expandable circular buffer. When the total number of point clouds corresponding to the multiple Morton point cloud blocks in the expandable circular buffer reaches the circular buffer threshold, the thread triggers a sequential write to disk, sorts the point clouds in the expandable circular buffer according to the order of the Morton codes from smallest to largest, and saves the sorted point clouds to binary segment files. After all threads have processed all point cloud blocks, multiple binary segment files are obtained.

[0074] This embodiment accelerates offline sorting through multi-threaded Morton encoding and threshold disk writing, thus solving the technical problem of slow import in existing technologies.

[0075] Preferably, S2 includes:

[0076] S21. Read the Morton point cloud block information in each binary segment file one by one. The Morton point cloud block information includes: level, Morton code, total number of points, and offset of each point in the binary segment file.

[0077] S22. Count the total number of point clouds corresponding to the Morton point cloud blocks under the same level, and calculate the overall size required for the target file based on the total number of point clouds;

[0078] S23. Reserve a contiguous storage area in the target file for each Morton point cloud block at the same level, and record the starting byte position of each segment;

[0079] S24. Based on the starting byte position of each segment, calculate the final write address of each Morton point cloud block in the target file, and at the same time calculate the cumulative offset within the segment;

[0080] S25. Generate a newly named binary segment file as the target file;

[0081] S26. Copy the data of each Morton point cloud block to the target file simultaneously according to the starting byte position and the final write address;

[0082] S27. Write an index record for each segment. The index record includes: level, Morton code, segment start address, and total number of point clouds. Calculate the sum of all index records, the total number of points in all index records, and the maximum and minimum values ​​of the X, Y, and Z coordinates of the total point cloud in all index records to obtain statistical information. Update the statistical information to the header information of the target file.

[0083] Preferably, S3 includes:

[0084] S31. For each Morton point cloud block in the target file, calculate the voxel side length and diagonal length of the point cloud data based on the bounding box and target level.

[0085] S32. Construct a first set for recording occupied voxels and a second set for recording the coordinate information of the first reserved point in the occupied voxels. Both the first set and the second set reserve capacity by dividing the number of input points by 8.

[0086] S33. Pre-list the coordinate offsets of 27 voxels consisting of 1 voxel and 26 neighboring voxels of the voxel;

[0087] S34. Perform the following operations for each input point cloud: locate the voxel key of the current point cloud; if the voxel is already occupied, skip the current point; if the voxel is not occupied, check if there is a reserved point among the 26 neighboring voxels and the distance is less than the voxel diagonal; if there is a reserved point and the distance is less than the voxel diagonal, skip the current point; if the current point is not skipped, write the current point into the second set and record the mapping from the voxel key to the coordinates of the current point, mark the voxel as occupied in the first set, and attach the true level and average point distance;

[0088] S35. Output the second set and trim it to the reserved capacity to obtain the sampled point cloud data.

[0089] Preferably, in S31, the formula for calculating the voxel side length s(L) is:

[0090] ;

[0091] Where L is the target level and L0 is the length of one side of the bounding box.

[0092] Preferably, in S6, "meeting the condition" means that a Morton point cloud block simultaneously meets the following two conditions:

[0093] Bounding box condition: A Morton point cloud block has eight vertices, and one vertex is inside the bounding box;

[0094] Angle condition: A Morton point cloud patch has eight vertices, one of which is inside the view frustum. The vertex inside the view frustum satisfies the following formula:

[0095] ;

[0096] Where a is the vector of the line connecting the camera center to the observation center, b is the vector of the line connecting the camera center to the vertex, and FOV is the field of view angle.

[0097] Preferably, in S5, the mapping relationship between focal length and average point distance is as follows:

[0098] ;

[0099] in, Focal length The average point distance, From the perspective of This represents the number of pixels on the vertical tangent line of the screen within the viewpoint's field of view.

[0100] Preferably, S7 includes: a background thread asynchronously reading the sampled point cloud data corresponding to the LOD node in the loading list into the CPU memory; the main thread loading the sampled point cloud data in the CPU memory into the VBO through OpenGL API functions; drawing the data in the VBO offline into the FBO through OpenGL API functions; during the display process, OpenGL operates the default buffer to draw the data in the FBO into the default buffer for rendering.

[0101] Finally, it should be noted that the above embodiments are merely preferred embodiments of the present invention used to illustrate the technical solutions of the present invention, and are not intended to limit the invention, nor are they intended to limit the patent scope of the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. These modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention. That is to say, any changes or refinements made to the main design concept and spirit of the present invention that are not of substantial significance, but whose technical problems are still consistent with the present invention, should be included within the protection scope of the present invention. In addition, the direct or indirect application of the technical solutions of the present invention to other related technical fields are similarly included within the patent protection scope of the present invention.

Claims

1. A method for real-time visualization of a massive point cloud with uniform sampling, characterized in that, The method comprises the following steps: S1, obtaining original point cloud data; performing multi-threaded Morton coding on the original point cloud data to obtain a plurality of binary segment files; S2, merging the plurality of binary segment files by using a k-way merging algorithm to obtain a target file; S3, performing hierarchical uniform sampling on the point cloud data in the target file to obtain sampled point cloud data; S4, grouping the sampled point cloud data according to corresponding levels to corresponding LOD nodes, and recording the average point distance of the sampled point cloud data in each LOD node in the target file, and the node bounding box in each LOD node; S5, based on the mapping relationship between the focal length and the average point distance, each average point distance corresponds to a level, and each level and the focal length corresponding to each level are stored in an array; S6, using a view frustum and a node bounding box to do containment or intersection test, and adding the LOD node meeting the condition and having a level less than or equal to a target level to a loading list; S7, a background thread asynchronously reads the sampled point cloud data corresponding to the LOD node in the loading list to the CPU memory, and uploads the data to the GPU in real time through double-buffer FBO; S3 comprises: S31, calculating the voxel edge length and the diagonal length of the point cloud data according to the bounding box of each Morton point cloud block in the target file and the target level; S32, constructing a first set for recording occupied voxels and a second set for recording the first reserved point coordinate information in the occupied voxels, and the first set and the second set both reserve a capacity according to the input point number divided by 8; S33, listing 27 voxel coordinate offsets composed of 1 voxel and 26 adjacent voxels of the voxel in advance; S34, for each input point cloud, the following operations are performed: locating the voxel key where the current point cloud is located; if the voxel has been occupied, skip the current point; if the voxel has not been occupied, check whether there is a reserved point in the 26 adjacent voxels and the distance is less than the voxel diagonal, if there is a reserved point and the distance is less than the voxel diagonal, skip the current point; when the current point is not skipped, write the current point into the second set and record the mapping of the voxel key of the current point to the coordinate, mark the voxel as occupied in the first set, and append the real level and the average point distance; S35, outputting the second set and clipping to the reserved capacity to obtain the sampled point cloud data.

2. The method of claim 1, wherein, S1 comprises: S11, setting parameters: setting the point cloud block size according to the hardware memory, the bit width of the Morton coding is 21 bits, the preset level is 8 layers, and the circular buffer threshold is 1 million points; S12, according to the number of CPU cores of the computer, a number of threads equal to the number of CPU cores are allocated, and an independent scalable circular buffer is allocated for each thread; S13, loading the original point cloud file into the memory, dividing all the original point cloud data in the original point cloud file into a plurality of point cloud blocks according to the point cloud block size; and distributing the plurality of point cloud blocks to a multi-threaded work queue. S14, each thread adopts a Morton coding algorithm to perform blocking on the current point cloud block at all levels to obtain a plurality of Morton point cloud blocks at all levels, each of which has a Morton code; and stores the plurality of Morton point cloud blocks in a scalable circular buffer, and when the total number of points corresponding to the plurality of Morton point cloud blocks in the scalable circular buffer reaches a circular buffer threshold, the thread triggers a sequential disk writing once, sorts the point clouds in the scalable circular buffer in ascending order of the Morton codes, and saves the sorted point clouds to a binary segment file, and when all threads process all point cloud blocks, a plurality of binary segment files are obtained.

3. The method of claim 2, wherein, S2 comprises: S21, read the Morton point cloud block information in each binary segment file one by one, the Morton point cloud block information comprising: level, Morton code, total number of points, and offset of each point in the binary segment file; S22, count the total number of points corresponding to the Morton point cloud blocks at the same level, and calculate the overall capacity required by the target file according to the total number of points; S23, reserve a continuous storage interval in the target file for each Morton point cloud block at the same level, and record the starting byte position of each interval; S24, calculate the final write address of each Morton point cloud block in the target file according to the starting byte position of each interval, and calculate the cumulative offset in the interval; S25, generate a newly named binary segment file as the target file; S26, copy the data of each Morton point cloud block to the target file according to the starting byte position and the final write address; S27, write an index record for each interval, the contents of the index record comprising: level, Morton code, starting address of the interval, and total number of points; count the total number of points, the maximum and minimum values of the X, Y and Z coordinates of the total points in all index records to obtain statistical information; and update the statistical information to the header information of the target file.

4. The method of claim 1, wherein, In S31, the calculation formula of the voxel side length s(L) is: ； wherein, L is the target level, and L0 is the length of a side of the bounding box.

5. The method of claim 1, wherein, In S6, the condition means that a Morton point cloud block meets the following two conditions: Bounding box condition: one of the eight vertices of a Morton point cloud block is in the bounding box; Angle condition: one of the eight vertices of a Morton point cloud block is in the view frustum, and the vertex in the view frustum satisfies the following formula: ； wherein, a is the vector of the line connecting the camera center to the observation center, b is the vector of the line connecting the camera center to the vertex, and FOV is the field of view angle.

6. The method of claim 1, wherein, In S5, the mapping relationship between the focal length and the average point distance is: ； wherein, is the focal length, is the average point distance, is the viewing angle, is the number of pixels on the longitudinal tangent of the screen within the field of view of the point of view.

7. The method of claim 1, wherein, S7 comprises: a background thread asynchronously reads the sampling point cloud data corresponding to the LOD nodes in the loading list to the CPU memory; a main thread loads the sampling point cloud data in the CPU memory to a VBO through an API function of OpenGL; the data in the VBO is offline rendered to an FBO through an API function of OpenGL; and in the display process, the OpenGL operation draws the data in the FBO to a default buffer for rendering.

Images