Fast, low-memory processing methods and systems for massive point cloud data

Abstract

This application relates to the field of computer technology and discloses a fast, low-memory processing method and system for massive point cloud data. The method includes: constructing an octree framework and leaf nodes based on the point cloud data; wherein, when constructing leaf nodes, the relationship between each point cloud data and its corresponding leaf node is recorded to form a leaf node dataset; when the number of point cloud data corresponding to any leaf node exceeds an allowed capacity threshold, a sub-octree and its leaf nodes are generated through the corresponding continuous point cloud data interval; and, following the order from leaf nodes to the root node, non-leaf nodes of the octree framework are constructed based on all leaf nodes, wherein each non-leaf node is aggregated and thinned to generate the octree. This application can more effectively reduce the memory usage in the process of constructing a massive point cloud octree and significantly reduce the time consumed in the process.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to the technology for processing massive point cloud data. Background Technology

[0002] In recent years, 3D laser scanning technology has been widely used in fields such as large-scale topographic mapping. When the survey area is large, it can quickly and accurately collect a large amount of point cloud data, effectively saving manpower and resources, shortening the construction period, and improving work efficiency and economic benefits. In complex terrain and dangerous survey areas, it can collect field data in detail and quickly without directly contacting dangerous targets, which not only ensures the safety of personnel and equipment, but also ensures the accuracy requirements of mapping, while improving work efficiency.

[0003] Point cloud data processing plays a crucial role in the aforementioned fields and others. Point cloud data refers to a collection of vectors in a three-dimensional coordinate system, where scanned data is recorded in the form of points, each containing three-dimensional coordinates, and some may contain color information (RGB) or reflectance intensity information.

[0004] Processing massive point cloud data has always been a major challenge, especially quickly constructing an octree structure from massive point clouds. Usually, constructing an octree structure from a point cloud involves loading the entire point cloud into memory, and the depth or resolution of the octree needs to be set in advance before constructing the octree structure. The octree is considered to be completed when the specified depth or resolution is reached.

[0005] There are still some problems in the existing technology, such as the large memory usage, long time consumption, and complex processing logic in the process of building octrees from massive point clouds. Summary of the Invention

[0006] The purpose of this application is to provide a fast, low-memory processing method and system for massive point cloud data, which can more effectively reduce the memory usage in the process of constructing massive point cloud octrees, significantly reduce the time spent in the process of constructing massive point cloud octrees, and simplify the processing logic of constructing massive point cloud octrees.

[0007] Each non-leaf node of the octree framework

[0008] This application discloses a fast, low-memory processing method for massive point cloud data, including:

[0009] An octree framework and leaf nodes are constructed based on point cloud data. When constructing leaf nodes based on point cloud data, the relationship between each point cloud data and the corresponding leaf node is recorded to form a leaf node dataset. The dataset includes the number of point cloud data corresponding to each leaf node and the range of continuous point cloud data.

[0010] When the number of point cloud data corresponding to any leaf node exceeds the allowable threshold, a sub-octree and its leaf nodes are generated through the corresponding continuous point cloud data interval.

[0011] Following the order from leaf nodes to root node, non-leaf nodes of the octree framework are constructed based on all leaf nodes. Each non-leaf node is aggregated and thinned to generate the octree.

[0012] In a preferred embodiment, the step of constructing the octree framework and leaf nodes based on the point cloud data further includes:

[0013] Based on the actual total number of points and the estimated depth of the point cloud data in the point cloud file, an octree framework corresponding to the point cloud data is constructed; wherein...

[0014] The initial depth is calculated based on the actual total number of points and the first threshold.

[0015] The expansion depth is obtained based on the actual total number of points;

[0016] The estimated depth is obtained based on the initial depth and the expansion depth.

[0017] In a preferred embodiment, the aggregation and thinning of each non-leaf node further includes:

[0018] In parallel, each non-leaf node of the octree framework is aggregated. For each non-leaf node in the octree framework, if the number of points in the point cloud data of the non-leaf node exceeds the aggregation threshold, the non-empty child nodes of the non-leaf node are retained and the empty child nodes are deleted; otherwise, all child nodes of the non-leaf node are deleted.

[0019] In a preferred embodiment, the thinning of each non-leaf node of the octree framework in parallel is performed by random thinning.

[0020] This application also discloses a fast, low-memory processing system for massive point cloud data, including:

[0021] The leaf node construction unit is used to construct an octree framework and leaf nodes based on point cloud data. The multi-level octree framework is reconstructed for each large leaf node until there are no large leaf nodes in the octree.

[0022] A non-leaf node construction unit is used to construct non-leaf nodes of an octree framework based on the point cloud data, wherein each non-leaf node is aggregated and thinned.

[0023] The new octree building unit is used to construct a new octree corresponding to the original point cloud data based on the constructed leaf nodes and non-leaf nodes.

[0024] This application also discloses a fast, low-memory processing device for massive point cloud data, comprising:

[0025] Memory, used to store computer-executable instructions; and,

[0026] A processor for implementing the steps of the method as described above when executing the computer-executable instructions.

[0027] This application also discloses a computer-readable storage medium storing computer-executable instructions that, when executed by a processor, implement the steps of the method described above.

[0028] In this implementation, firstly, there is no need to pre-set the maximum depth or minimum resolution of the octree before constructing it. The depth of the octree is dynamically adjusted according to the spatial distribution characteristics of the point cloud. After the octree is constructed, the number of points in all octree nodes does not exceed the rendering limit, ensuring normal rendering. Furthermore, the spatial distribution of the point cloud data is quickly obtained by traversing the point cloud data, and the point cloud data is directly copied from the original point cloud file when organized by nodes in a custom file, eliminating the need to cache the point cloud data in memory. Additionally, there is no need to save point cloud data to an intermediate file by writing points, reducing the number of point writes. Thread synchronization is not required when writing points to the custom organization file, all of which contribute to reduced rendering time.

[0029] Overall, the technical solution of this application can more effectively reduce the memory usage in the process of building a massive point cloud octree, significantly reduce the time spent in the process of building a massive point cloud octree, and simplify the processing logic of building a massive point cloud octree.

[0030] The specification of this application contains numerous technical features distributed across various technical solutions. Listing all possible combinations of these technical features (i.e., technical solutions) would make the specification excessively lengthy. To avoid this problem, the various technical features disclosed in the above-described invention, the various technical features disclosed in the following embodiments and examples, and the various technical features disclosed in the accompanying drawings can be freely combined to form various new technical solutions (all of which are considered to have been described in this specification), unless such a combination of technical features is technically infeasible. For example, one example discloses feature A+B+C, and another example discloses feature A+B+D+E. Features C and D are equivalent technical means that serve the same function, and technically only one needs to be used; they cannot be used simultaneously. Feature E can technically be combined with feature C. Therefore, the solution A+B+C+D should not be considered as described because it is technically infeasible, while the solution A+B+C+E should be considered as described. Attached Figure Description

[0031] Figure 1 This is a schematic diagram of a multilevel octree;

[0032] Figure 2 This is a schematic diagram of the main steps of the fast, low-memory processing method for massive point cloud data according to this application;

[0033] Figure 3 This is a partial flowchart of the fast, low-memory processing method for massive point cloud data according to this application;

[0034] Figure 4 This is a schematic diagram of the original point cloud file and leaf nodes in the fast and low-memory processing method for massive point cloud data according to this application;

[0035] Figure 5 This is a schematic diagram of the non-leaf nodes of an octree constructed in the fast, low-memory processing method for massive point cloud data according to this application.

[0036] Figure 6 This is a schematic diagram of node aggregation of an octree in the fast and low-memory processing method for massive point cloud data according to this application.

[0037] Figure 7 This is a flowchart illustrating a fast, low-memory processing method for massive point cloud data according to the first embodiment of this application.

[0038] Figure 8 This is a schematic diagram of the structure of a fast, low-memory processing system for massive point cloud data according to the second embodiment of this application. Detailed Implementation

[0039] In the following description, many technical details are presented to help the reader better understand this application. However, those skilled in the art will understand that the technical solutions claimed in this application can be implemented even without these technical details and various variations and modifications based on the following embodiments.

[0040] The following is a brief summary of some of the innovative aspects of this application:

[0041] The inventors of this application, after years of research, discovered the problems existing in the prior art and creatively proposed a fast and low-memory processing solution for massive point cloud data. Specifically, firstly, in the prior art, the depth or resolution of the octree needs to be set before construction. When the depth or resolution of the constructed octree reaches the set depth or resolution, the octree construction is completed. At this time, the number of points in the leaf nodes of the octree may exceed the maximum number of pixels for rendering, and cannot be rendered in one frame. In contrast, this application does not require presetting the maximum depth or minimum resolution of the octree before construction. The depth of the octree is dynamically adjusted according to the spatial distribution characteristics of the point cloud. After the octree is constructed, the number of points in all octree nodes does not exceed the number of points limited for rendering, and can be rendered normally. Second, in existing technologies, the entire point cloud needs to be loaded into memory before constructing the octree. However, massive point cloud files are too large to be loaded into memory all at once. To address this, this application quickly traverses the point cloud data to obtain its spatial distribution. Furthermore, when organizing the point cloud data by nodes in a custom file, it directly copies the data from the original point cloud file, eliminating the need to cache the point cloud data in memory. Third, existing octree construction schemes are too time-consuming. In this invention, there is no need to write points to intermediate files to save the point cloud data, reducing the number of point writes. When writing points to the custom organization file, thread synchronization is not required, all of which contribute to reduced time consumption.

[0042] Therefore, in summary, this application can more effectively reduce the memory usage in the process of constructing a massive point cloud octree, significantly reduce the time spent in the process of constructing a massive point cloud octree, and simplify the processing logic of constructing a massive point cloud octree.

[0043] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0044] The first embodiment of this application relates to a fast, low-memory processing method for massive point cloud data.

[0045] First, let me explain the multilevel octree framework used in this application.

[0046] like Figure 1 As shown, the octree in this invention is hierarchically structured, as follows: Figure 1As shown, the original octree is a level-zero octree. An octree constructed from all the "big leaf" nodes of the level-zero octree is a level-one octree, and so on. A "big leaf" node is a node whose corresponding point cloud data contains more points than the maximum number of points the node can hold. Therefore, constructing octrees from massive point cloud data in this invention is actually constructing multiple octrees from the point cloud data; a single octree is a special case of multiple octrees.

[0047] like Figure 2 As shown, the fast, low-memory processing method for massive point cloud data in this embodiment includes two main steps: the octree contains leaf nodes and non-leaf nodes. To construct an octree for massive point cloud data, first construct the framework and leaf nodes of the multiple octree, and then construct the non-leaf nodes of the multiple octree. The octree construction is completed when both leaf nodes and non-leaf nodes are constructed.

[0048] More specifically, the fast, low-memory processing method for massive point cloud data in this embodiment includes the following steps: constructing an octree framework and leaf nodes based on the point cloud data, wherein, when constructing leaf nodes based on the point cloud data, the relationship between each point cloud data and the corresponding leaf node is recorded to form a leaf node dataset, the dataset including the number of point cloud data corresponding to each leaf node and the continuous point cloud data interval; when the number of point cloud data corresponding to any leaf node exceeds the allowable capacity threshold, a sub-octree and its leaf nodes are generated through the corresponding continuous point cloud data interval; following the order from leaf node to root node, non-leaf nodes of the octree framework are constructed based on all leaf nodes, wherein each non-leaf node is aggregated and thinned to generate an octree.

[0049] It should be noted that in the embodiments of this application, the sub-octree may also have its own sub-octree.

[0050] The following is combined with Figure 2 The embodiments of this application are further explained and described in detail below:

[0051] Step 100: Construct the framework and leaf nodes of the octree based on the point cloud data.

[0052] It should be noted that an octree contains leaf nodes and non-leaf nodes. To construct an octree from a massive point cloud, the framework and leaf nodes of the multiple octrees must first be constructed.

[0053] In this step, an octree framework and leaf nodes are constructed based on the point cloud data. When constructing leaf nodes based on the point cloud data, the relationship between each point cloud data and the corresponding leaf node is recorded to form a leaf node dataset. The dataset includes the number of point cloud data corresponding to each leaf node and the continuous point cloud data interval. When the number of point cloud data corresponding to any leaf node exceeds the allowable capacity threshold, a sub-octree and its leaf nodes are generated through the corresponding continuous point cloud data interval.

[0054] Optionally, the step of constructing an octree framework and leaf nodes based on point cloud data may further include the following sub-steps: constructing an octree framework corresponding to the point cloud data based on the actual total number of points and the estimated depth of the point cloud data in the point cloud file; wherein, an initial depth is calculated based on the actual total number of points and a first threshold; an expansion depth is obtained based on the actual total number of points; and the estimated depth is obtained based on the initial depth and the expansion depth.

[0055] like Figure 3 The above, Figure 3 This is a flowchart illustrating the process of constructing multi-octagonal leaf nodes.

[0056] Step 110: Estimate the depth of the octree based on the number of points in the point cloud data in the original point cloud file and the maximum number of points that an octree node can accommodate, and construct a multi-level octree framework, wherein all nodes in the octree framework are empty nodes.

[0057] In this step, the depth of the octree is estimated based on the number of points in the point cloud data and the maximum number of points that an octree node can accommodate. The total bounding box of the point cloud data distribution is divided to construct an octree framework, and all nodes in the octree framework are empty nodes.

[0058] A bounding box is a cube that can enclose point cloud data.

[0059] Step 120: By traversing the original point cloud file, determine the number of points and the interval of consecutive points that each point cloud data falls within the boundingbox of each leaf node of the octree based on the spatial distribution of the point cloud data in the original point cloud file.

[0060] In this step, we traverse a large number of point cloud files to obtain the spatial distribution of the point cloud data, that is, the number of points and the intervals of consecutive points that fall within the bounding boxes of each leaf node of the octree.

[0061] Point cloud data obtained by lidar scanning has spatial continuity over time, therefore the point cloud data in the original point cloud file also has spatial continuity.

[0062] For example, the continuous point interval [point m, point n] of a leaf node means that all points between point m and point n are within the bounding box of that node, where point m represents the m-th point in the original point cloud file, and point n represents the n-th point in the original point cloud file. Figure 4 As shown, leaf node 1 has two consecutive point intervals [1,m] and [n+1,j], and leaf node 3 has one consecutive point interval [m+1,n].

[0063] Steps 130-140: If the number of points in the corresponding point cloud data within the bounding box of at least one leaf node in the octree exceeds its maximum capacity, that is, the number of point cloud data exceeds the allowed threshold, i.e., there is a large leaf node, then for each such large leaf node, the depth of the octree is re-estimated based on the number of points in the point cloud data and the maximum number of points that the octree node can accommodate, and a multi-level octree framework is constructed. Based on the spatial distribution of the point cloud data in the point cloud file, the number of points and the interval of continuous points that each point cloud data falls within the bounding box of each leaf node in the octree are determined. This process is repeated until there are no large leaf nodes in the octree, at which point the leaf nodes of the octree are constructed. In other words, a sub-octree and its leaf nodes are generated through the corresponding intervals of continuous point cloud data.

[0064] Preferably, steps 130 and 140 are implemented as follows:

[0065] Step 130: Determine whether there exists at least one leaf node in the octree whose corresponding point cloud data has more points than the maximum number of points that the node can accommodate. In other words, the number of point cloud data exceeds the allowed capacity threshold, i.e., there is a large leaf node. If so, execute step 140 for each large leaf node; otherwise, the leaf node construction of the octree is complete.

[0066] The leaf nodes in this step are "large leaf" nodes, which are nodes whose corresponding point cloud data has more points than the maximum number of points a node can hold.

[0067] Specifically, in this step, the leaf nodes of the octree are traversed to find the "large leaf" node. If the octree contains a "large leaf" node, the process jumps to... Figure 3 In step 140, if there is no "big leaf" node in the octree, then the leaf node construction of the octree is complete.

[0068] Step 140: Repeat steps 110 and 120 for each of the major leaf nodes until there are no major leaf nodes in the octree, at which point the leaf node construction of the octree is complete.

[0069] Specifically, in this step, the number of points and the interval of consecutive points in the point cloud data corresponding to the "large leaf" node are known. Steps 1 and 2 are repeated for all "large leaf" nodes to construct an octree. After the octrees for all "large leaf" nodes are constructed, the process jumps to step 130 to determine whether to continue constructing octrees. The octree constructed in the first execution of this step is a first-level octree, the octree constructed in the second execution is a second-level octree, the octree constructed in the third execution is a third-level octree, and so on.

[0070] When an octree no longer has a "big leaf" node and there is no need to rebuild the octree, the leaf nodes of the multi-octree are complete. The hierarchical relationship of the multi-octree is as follows: Figure 1 As shown.

[0071] It should be noted that in this step, only the point cloud data needs to be read. The advantage of doing so is that there is no need to write the point cloud to a file or cache the point cloud data, which greatly reduces memory usage and time consumption during the construction process.

[0072] Step 200: Construct the non-leaf nodes of the octree framework based on all leaf nodes, following the order from leaf nodes to root node. For each non-leaf node, perform aggregation and thinning to generate the octree. Step 210: Aggregate each non-leaf node of the octree framework in parallel. For each non-leaf node in the octree, if the number of points in the point cloud data of the non-leaf node exceeds a threshold, retain the non-empty child nodes of the non-leaf node and delete the empty child nodes; otherwise, delete all child nodes of the non-leaf node, thus making the non-leaf node a new leaf node.

[0073] Specifically, such as Figure 6 As shown, a thread pool is enabled to perform node aggregation on multiple octrees in parallel. The process of aggregating a single node in an octree is as follows: Figure 6 As shown. The algorithm determines whether the number of points in a non-leaf node exceeds a threshold, meaning the number of points in the point cloud data exceeds the maximum allowed number of points a node can hold. If so, it retains the non-empty child nodes of the node and deletes the empty child nodes; otherwise, it deletes all child nodes of the node, and the node becomes a new leaf node. If all child nodes of a non-leaf node are empty, the node becomes an empty leaf node after aggregation.

[0074] Step 220: Assign the corresponding point cloud data blocks in the custom organization file to each node of the aggregated octree.

[0075] Preferably, the length of nodes that do not require thinning in the file is the actual length of the corresponding point cloud data, while the length of nodes that require thinning in the file is the reserved length.

[0076] More specifically, in this step, the point cloud data is stored in the custom organization file according to octree nodes, that is, the point cloud data of one octree node is stored together. After the nodes of the octree, i.e., the multi-octree, are aggregated, the nodes of the multi-octree are determined. Each node of the multi-octree is assigned its point cloud data block in the custom organization file (file offset and length). The length of the node that does not need to be thinned in the file is the actual length of the corresponding point cloud data. The length of the node that needs to be thinned in the file is the reserved length. The length can be the maximum number of points that the node can hold multiplied by the number of bytes occupied by a single point.

[0077] The advantage of this approach is that when multiple octrees write the thinned results to the self-organizing file in parallel, there is no need for synchronization between threads, thus reducing processing time.

[0078] Step 230: Thin out each non-leaf node of the octree framework in parallel to complete the construction of the non-leaf nodes of the octree.

[0079] The thinning is achieved by random thinning. The advantage of this is that after thinning, the relatively sparse areas of the point cloud remain dense, ensuring that the relative density of the point cloud distribution remains unchanged after thinning.

[0080] The advantage of this approach is that it ensures that the number of nodes in each node of a multi-octree does not exceed a certain limit. Figure 6 The threshold in.

[0081] Step 300: Construct a new octree corresponding to the original point cloud data based on the constructed leaf nodes and non-leaf nodes.

[0082] Those skilled in the art will understand that, according to the technical solutions of the above embodiments, when constructing an octree from point cloud data, there is no need to use intermediate files or large caches to store point cloud data. When the point cloud data of the leaf nodes is written to a custom organization file, only data blocks need to be copied from the original point cloud file. Furthermore, when the point cloud data is thinned in parallel, there is no need for synchronization between threads, which can reduce the time consumption. Furthermore, the processing logic is simple.

[0083] Technical effects of this embodiment:

[0084] In the fast and low-memory processing method for massive point cloud data, it is not necessary to pre-set the maximum depth or minimum resolution of the octree before constructing it. The depth of the octree can be dynamically adjusted according to the spatial distribution characteristics of the point cloud. After the octree is constructed, the number of points in all octree nodes does not exceed the rendering limit, and it can be rendered normally.

[0085] In the fast and low-memory processing method for massive point cloud data, the spatial distribution of the point cloud data is obtained by quickly traversing the point cloud data. When the point cloud data is organized by node in a custom file, it is also copied directly from the original point cloud file, without needing to cache the point cloud data in memory.

[0086] In the fast and low-memory processing method for massive point cloud data, there is no need to save the point cloud data to an intermediate file by writing points, which reduces the number of point writing operations. When writing points to a custom organization file, there is no need for synchronization between threads, which can reduce the time consumption.

[0087] In summary, this application can more effectively reduce the memory usage in the process of constructing a massive point cloud octree, significantly reduce the time spent in the process of constructing a massive point cloud octree, and simplify the processing logic of constructing a massive point cloud octree.

[0088] The second embodiment of this application relates to a fast, low-memory processing system for massive point cloud data, the structure of which is as follows: Figure 2 As shown, the fast, low-memory processing system for this massive point cloud data includes:

[0089] An octree framework and leaf node construction unit is used to construct an octree framework and leaf nodes based on point cloud data. When constructing leaf nodes based on point cloud data, the relationship between each point cloud data and the corresponding leaf node is recorded to form a leaf node dataset. The dataset includes the number of point cloud data corresponding to each leaf node and the continuous point cloud data interval. When the number of point cloud data corresponding to any leaf node exceeds the allowable capacity threshold, a sub-octree and its leaf nodes are generated through the corresponding continuous point cloud data interval.

[0090] The non-leaf node building unit of the octree framework is used to construct the non-leaf nodes of the octree framework based on all leaf nodes in the order from leaf node to root node. Each non-leaf node is aggregated and thinned to generate an octree.

[0091] The first embodiment is a method embodiment corresponding to this embodiment. The technical details in the first embodiment can be applied to this embodiment, and the technical details in this embodiment can also be applied to the first embodiment.

[0092] It should be noted that those skilled in the art should understand that the implementation functions of each module shown in the above-described embodiments of the fast, low-memory processing system for massive point cloud data can be understood with reference to the relevant descriptions of the aforementioned fast, low-memory processing method for massive point cloud data. The functions of each module shown in the above-described embodiments of the fast, low-memory processing system for massive point cloud data can be implemented by a program (executable instructions) running on a processor, or by specific logic circuits. If the above-described fast, low-memory processing system for massive point cloud data in this application is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application embodiment, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), magnetic disks, or optical disks. Thus, the embodiments of this application are not limited to any particular combination of hardware and software.

[0093] Accordingly, this application also provides a computer storage medium storing computer-executable instructions, which, when executed by a processor, implement the various method implementations of this application.

[0094] Furthermore, this application also provides a fast, low-memory processing device for massive point cloud data, including a memory for storing computer-executable instructions and a processor; the processor is used to implement the steps in the above-described method embodiments when executing the computer-executable instructions in the memory. The processor may be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The aforementioned memory may be read-only memory (ROM), random access memory (RAM), flash memory, hard disk, or solid-state drive, etc. The steps of the methods disclosed in the embodiments of this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules in the processor.

[0095] It should be noted that in this patent application, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one" does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element. In this patent application, if it refers to performing an action according to an element, it means performing the action at least according to that element, including two cases: performing the action only according to that element, and performing the action according to that element and other elements. Expressions such as "multiple," "repeatedly," and "various" include two, two times, two kinds, and more than two, more than two times, and more than two kinds.

[0096] All documents mentioned in this application are considered to be incorporated in their entirety into the disclosure of this application so that they can serve as a basis for modifications if necessary. Furthermore, it should be understood that after reading the foregoing disclosure of this application, those skilled in the art can make various alterations or modifications to this application, and these equivalent forms also fall within the scope of protection claimed in this application.

Claims

1. A fast, low-memory processing method for massive point cloud data, characterized in that, include: Based on the actual total number of points and the estimated depth of the point cloud data in the point cloud file, an octree framework corresponding to the point cloud data is constructed; wherein, the initial depth is calculated based on the actual total number of points and a first threshold; the expansion depth is obtained based on the actual total number of points; and the estimated depth is obtained based on the initial depth and the expansion depth. By traversing the original point cloud file, the relationship between each point cloud data and its corresponding leaf node is recorded according to the spatial distribution of the point cloud data in the original point cloud file, forming a leaf node dataset. The leaf node dataset includes the number of point cloud data corresponding to each leaf node and the continuous point cloud data interval. The continuous point cloud data interval is represented as [point m, point n], which is used to characterize that the m-th to n-th points in the original point cloud file all fall within the bounding box of the corresponding leaf node, where m and n are the sequential numbers of the points in the original point cloud file. Furthermore, in the process of constructing the octree framework and leaf nodes, only the point cloud data in the original point cloud file is read to obtain its spatial distribution, without caching the point cloud data in memory or writing the point cloud data to an intermediate file. When the number of point cloud data corresponding to any leaf node exceeds the allowable capacity threshold, a sub-octree and its leaf nodes are generated from the point cloud data of the corresponding continuous point cloud data interval until there are no leaf nodes in the octree whose corresponding number of point cloud data exceeds the allowable capacity threshold. Following the order from leaf nodes to root node, an octree framework of non-leaf nodes is constructed based on all leaf nodes. Each non-leaf node is aggregated and thinned to generate an octree. Aggregation is performed on each non-leaf node of the octree framework in parallel. For each non-leaf node in the octree framework, if the number of points in the point cloud data of that non-leaf node exceeds the aggregation threshold, then the non-empty child nodes of that non-leaf node are retained and the empty child nodes are deleted; otherwise, all child nodes of that non-leaf node are deleted. Furthermore, the thinning is implemented using random thinning. Before thinning each non-leaf node of the octree framework in parallel, each node of the aggregated octree is assigned a corresponding point cloud data block in a custom organization file. For nodes that do not require thinning, the length in the custom organization file is the actual length of the corresponding point cloud data; for nodes that require thinning, the length in the custom organization file is a reserved length. This ensures that threads do not need to synchronize when multiple octrees write the thinning results to the custom organization file in parallel. For leaf nodes, when writing to the custom organization file according to the node's point cloud data organization, data blocks are directly copied from the original point cloud file.

2. A fast, low-memory processing system for massive point cloud data, characterized in that, include: An octree framework and leaf node construction unit are used to construct an octree framework corresponding to the point cloud data based on the actual total number of points and the estimated depth in the point cloud data in the point cloud file. Specifically, an initial depth is calculated based on the actual total number of points and a first threshold; an expansion depth is obtained based on the actual total number of points; the estimated depth is obtained based on the initial depth and the expansion depth; and by traversing the original point cloud file and recording the relationship between each point cloud data and its corresponding leaf node according to the spatial distribution of the point cloud data in the original point cloud file, a leaf node dataset is formed. The leaf node dataset includes the number of point cloud data corresponding to each leaf node and a continuous point cloud data interval; the continuous point cloud data interval is represented as [point m...]. [m, n] is used to characterize that all points from the mth to the nth in the original point cloud file fall within the bounding box of the corresponding leaf node, where m and n are the sequential numbers of the points in the original point cloud file; and, in the process of constructing the octree framework and leaf nodes, only the point cloud data in the original point cloud file is read to obtain its spatial distribution, without caching the point cloud data in memory or writing the point cloud data to an intermediate file; when the number of point cloud data corresponding to any leaf node exceeds the allowable capacity threshold, a sub-octree and its leaf nodes are generated through the point cloud data of the corresponding continuous point cloud data interval, until there are no leaf nodes in the octree whose corresponding number of point cloud data exceeds the allowable capacity threshold; The non-leaf node construction unit of the octree framework is used to construct non-leaf nodes of the octree framework based on all leaf nodes in the order from leaf nodes to root node. Each non-leaf node is aggregated and thinned to generate an octree. The aggregation of each non-leaf node in the octree framework is performed in parallel. For each non-leaf node in the octree framework, if the number of points in the point cloud data of the non-leaf node exceeds the aggregation threshold, then the non-empty child nodes of the non-leaf node are retained and the empty child nodes are deleted; otherwise, all child nodes of the non-leaf node are deleted. The thinning is implemented by random thinning. Furthermore, the non-leaf nodes are aggregated and thinned in parallel. Before thinning each non-leaf node of the octree framework, each node of the aggregated octree is assigned a corresponding point cloud data block in a custom organization file. For nodes that do not require thinning, the length in the custom organization file is the actual length of the corresponding point cloud data; for nodes that require thinning, the length in the custom organization file is a reserved length. This ensures that threads do not need to synchronize when multiple octrees write the thinning results to the custom organization file in parallel. For leaf nodes, when writing to the custom organization file according to the node's point cloud data organization, data blocks are directly copied from the original point cloud file.

3. A fast, low-memory processing device for massive point cloud data, characterized in that, include: Memory is used to store executable instructions for a computer; as well as, A processor configured to implement the steps of the method as claimed in claim 1 when executing the computer-executable instructions.

4. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions that, when executed by a processor, implement the steps of the method as described in claim 1.

Images