Patent Grant
11710211
The current application is directed to computational transformations, decompositions, searching, data sampling, and other operations that can achieve significant computational and thermodynamic efficiencies in many problem domains, including 3D-space search, k nearest neighbors, and point-cloud registration with an array based data repository.
A point cloud is a 3D data set collected by various sensors, such as light detection-and-ranging “LIDAR” sensors, depth cameras, and others. Point cloud registration iteratively aligns a new frame of a 3D data set with previous aligned frames, referred to as a “map.” In many applications, a sensor moves in a 3D space with six degrees of freedom and each new frame relates to a previous frame or to a set of aligned previous frames by a spatial transformation. The registration of a sequence of frames of a 3D data set is a process that involves finding the rigid transformations, consisting of translations and rotations, that align the frames in a selected coordinate system.
Point cloud registration has a broad range of applications in areas including computer vision, simultaneous localization and mapping (“SLAM”), robot-path planning, autonomous driving, object recognition, medical imaging, magnetic-resonance imaging, virtual and augmented reality, and 3D model construction in remote sensing. Many new applications have become possible, in recent years, due to rapid advances in sensing and computing technologies, as a result of which 3D data-set registration is becoming an increasingly significant component within many scientific, technological, and commercial applications and fields.
Iterative Closest Point (“ICP”) and Generalized Iterative Closest Point (“GICP”) are widely adopted approaches for point-cloud registration. As suggested by its name, ICP depends on iterative searching of 3D spaces and, indeed, its performance is dominated by the cost of such searches. K-d trees and other tree-based approaches are used to search for closest points, and these tree-based approaches involve expensive tree traversals and re-balancing. Empirical testing has shown that it is unrealistic to perform real-time point cloud registration with any known tree-based approach to 3D space searching in order to meet a desired precision.
A point cloud frame is generally compressed by sampling to reduce its cardinality prior to frame alignment in order to decrease processing costs. To ensure that the compression does not result in significant decrease in accuracy, many compression techniques are designed to ensure that each 3D voxel contains only up to a threshold number of data points by removing data points from those 3D voxels with more than the threshold number of data points. Octree has been suggested and used for these compression techniques, which uses a storage space of a size proportional to the product of the ranges of the spatial coordinates in each of the three dimensions and which employs processing times proportional to the logarithm of the size of the octree for each point examined. The aligned point cloud frames, or map, produced by point-cloud registration is stored in a data repository. The data repository is incrementally built up along with the processing of each new frame, and, at the same time, is searched repeatedly for certain points in each frame.
As is well understood by those familiar with science and technology, the computational efficiency of a method or subsystem within a computer system, measured by the number of instructions processed and the amount of memory used to carry out particular tasks, is directly related to thermodynamic efficiency of the computer system, and is a significant real-word, physical characteristic of electromechanical computing systems. The time efficiency of a method or subsystem within a computer system is directly related to the real-world performance of the physical computer system and is often a significant determinant of the practical utility of the computer system in real-world applications. As with any significant component of an application, technology, or system, researchers, designers, developers, manufacturers, and vendors continuously seek more efficient and faster 3D-data-set-registration methods and systems, and seek improved efficiencies in many other, related applications and problem domains.
The current document is directed to a dimensional shuffle transform (“DST”) that maps a 3D space to a one-dimensional space with an implicit recursive hierarchical structure that preserves 3D neighborhoods. A regional or neighborhood search for points in a 3D subspace is reduced, by the DST, to one or more searches in the transformed 1D space. The search is performed by either recursive decomposition of the 3D space indexed by the transform into subspaces, exploiting the transformed space structure, or by direct indexing into the region of interest. This approach to searching a 3D space using the DST Transform has been shown, by both theoretical analysis and empirical testing, to be more time-efficient and space-efficient and to provide better performance in recall and precision than currently used approaches based on k-d trees, octal trees, and their many variants. Moreover, the searches over the subspaces generated by recursive decomposition are completely independent from one another, providing many opportunities for a variety of parallel, DST-enabled search methods. The DST provides a basis for fast and efficient iterative closest point search and compression of point clouds while avoiding construction and traversal of tree-like data structures. The performance of the system is further enhanced with the black-white array (“BWA”), disclosed in this document, which supports the search over the one dimensional space derived from DST transform without the need for pointer chasing and rebalancing of a tree structure, as found in tree-based solutions typified by the well-known red-black tree.
A point p in a discrete 3D space (D3) can be represented by a tuple of three coordinates (z, y, x), where z, y, x are nonnegative integers and are each referred to as a coordinate of point p along their respective coordinate axis, Z, Y, or X, of the 3D space. A point in a 1D space is represented by a single nonnegative coordinate k along a single axis of the 1D space. The Euclidian metric for distance is assumed for the space unless otherwise specified, although certain of the following discussions may be valid for additional distance metrics, such as the Manhattan distance metric.
Let p1=(z1, y1, x1) and p2=(z2, y2, x2) be two points in D3. These two points define a regular region, denoted by <p1, p2>, with a cubic shape:
<p1, p2>={p=(z, y, x)|min(z1,z2)≤z≤max(z1,z2);
min(y1,y2)≤y≤max(y1,y2);
min(x1,x2)≤x≤max(x1,x2)}.
Note that when one, two, or three of the conditions z1≠z2, y1≠y2, and x1≠x2 is/are not met, the region R degenerates to a plane, a line, or a point respectively. A regular region r′ is a sub-region of a region r if and only if, considering r′ and r as sets:
r′⊂r.
The following are operations over binary numbers and integers:
The notations: ∥ and && denote the logical OR and AND of predicates respectively, |, &, and {circumflex over ( )} are used to denote, respectively, the bitwise OR, AND, and ExclusiveOR operations of two unsigned integers, while ˜ denotes the bitwise complement of an unsigned integer; <<m and >>m denote respectively the left and right shift by m bit positions of an unsigned integer.
The Dimensional Shuffle Transform (“DST”) is a mapping from three-dimensional space D3 to one-dimensional space D1, as defined below:
where w is the width, in bits, of a 3D coordinate along a 3D dimension. Given a point p in D3, the DST Transform of the point, k=H(p), is referred to as the DST key of the point p.
The result returned is a tuple of the 3D coordinates in the form of (z,y,x).
The DST Transform has the property of preserving neighborhoods in that points close to one another in the 3D space tend to be close to one another in the transformed space. Another way of looking at DST Transform is that the DST Transform imposes an implicit hierarchical recursive structure over the 3D space, where the original space, which can be considered to be the root cube with edges of length 2a, is conceptually divided into eight sub-cubes with edges of length a. The division can be recursively performed on the sub-cubes and their sub-cubes until the sub-cubes degenerate to a point, where the number of points along each sub-cube edge is one. The assertion that DST is a neighborhood preserving transform can then be formally justified by the fact that the DST keys of the all the points in a cube or sub-cube in this hierarchical structure always form a linear set of keys with monotonically increasing consecutive values [s,t]={k|s≥k≥t}. for two integer keys s and t, which will be referred to as the lower front and upper back corner of the cube or sub-cube, respectively.
The overall cubic space 404 shown in
Given two keys k1 and k2, the regular region defined by the two keys, denoted by <k1, k2>, is given by {(z, y, x)|min(x1, x2)≤x≤max(x1, x2), min(y1, y2)≤y≤max(y1, y2), min(z1, z2) max(z1, z2)}, where (z1, y1, x1)=H−1(k1), (z2, y2, x2)=H−1(k2). A pair of keys k1=H(z1, y1, x1), and k2=H(z2, y2, x2) is said to be canonical if x1≤x2, y1≤y2, and z1≤z2 hold at the same time. With canonical pairs of keys, the definition of a regular region can be simplified as <k1, k2>={(z, y, x)|x1≤x≤x2, y1, ≤y≤y2, z1≤z2}. It is apparent that any pair of keys can be easily converted into a canonical pair of keys which defines exactly the same regular region. Hence, without loss of generality, we will use only canonical pairs to define a region.
The linear region defined by the two keys, denoted by [k1,k2], is given by {(z, y, x)|k1≤H(z, y, x)≤k2}. It can be easily shown that <k1, k2>⊆[k1, k2] always holds. Hence, a linear region [k1, k2] always has a recall of 100% when used to approximate a regular region<k1, k2>, for every point in the latter is necessarily contained in the set of the former.
The precision of a region defined by two keys (k1, k2) is given by Prec(k1, k2)=|<k1, k2>|/|[k1, k2]|, where |S| denotes the cardinality of a set S. It follows that the precision of a region is always less than or equal to one. A region with precision one is a perfect region and a region with precision one and with the lengths of each edge along all dimensions equal to one another is referred to as a perfect cube.
The DST level is a fundamental characteristic of a region, which among other applications, is used in determining dividing planes during region-decomposition operations. The level of region defined by two keys k1, k2 is calculated by the method “Lvl,” as follows:
Given two keys k1 and k2, Lvl(k1, k2) calculates the level of the regular region <k1, k2>. In the code shown above, w is the width of each 3D coordinate's binary form, in bits. The routine Lvl examines the binary bits in k=k1 XOR k2 in successive blocks of three bits from left to right, and then finds the index of the three-bit block containing the left-most 1-valued bit or bits in k, which represent the most significant bit or bits of the 3D coordinates corresponding to the keys k1 and k2 that differ.
A non-perfect region with a volume greater than the smallest possible volume of a region can always be decomposed into sub-regions with better, if not perfect, precisions. The decomposition is done in a way that maximizes the precision. The following method Pat is an auxiliary method used in the determination of an optimal decomposition:
Given two keys k1 and k2 and a pre-calculated level of <k1, k2>, Pat(k1, k2) calculates the pattern of the defined region, subsequently used in the decomposition of the region. The pattern is necessarily an integer with an integer value in the range 1, . . . , 7. The pattern, in its binary form (b2, b2, b1), indicates the dividing axes in a decomposition. When there is only one non-zero bit in the pattern, the region is decomposed by dividing the region by a plane perpendicular to the axis corresponding to the position of the bit in the pattern. When there are two non-zero bits, the region is decomposed by two planes perpendicular to the corresponding axes indicated by the pattern. When there are three non-zero bits, the region is decomposed by dividing the region by three mutually perpendicular planes.
Two auxiliary methods are used to identify the corners of the perfect region in which a point resides, given a particular level. Given the key of a point and a level, the following method LowerFt calculates the lower front corner of the perfect cube at the given level to which the point belongs. The method LowerFt sets each of the least significant 3*L bits of the key to the bit value 0.
Given the key of a point and a level, the method UpperBk calculates the upper back corner of the perfect cube at the given level to which the point belongs:
Given three keys k1, k2, and k3, the following utility method C returns the concatenated 3D coordinates of a point that has the same x coordinate as the 3D point corresponding to k1, the same y coordinate as the 3D point corresponding to k2, and the same z coordinate as the 3D point corresponding to k3, using predefined bit masks XMask=(001001 . . . 001), YMask=(010010 . . . 010), and ZMask=(100100 . . . 100):
An m-ary decomposition for a given pattern P is written as ΠP(k1, k2)=((k10, k11), . . . , (km−10, km−11)). The m subregions are each specified by a pair of canonical keys. It follows that besides k1 and k2, 2m−2 keys need to be calculated. It turns out that all the 2m−2 keys can be efficiently derived from k1, k2, u=upperBk(k1,L), and v=lowerBk(k2, L), where L=Lvl (k1, k2, w).
For example, the three methods, with names Π1, Π2, and Π4, where the superscript 1 represents the binary pattern 001, the superscript 2 represents the binary pattern 010, and the superscript 4 represents the binary pattern 100, carry out a binary decomposition of a region <k1, k2> of given level L. The method Π1 is next provided:
The above method performs a binary decomposition of a region along the X axis. Similarly constructed methods Π2 and Π4 perform binary decompositions along the Y and Z axes, respectively.
The method Π3 carries out a quaternary decomposition of a region <k1, k2> in accordance with pattern 011 (504 in
Methods Π5 and Π6 are similarly constructed. Method Π7 performs an octonary decomposition along all axes for the pattern 111 (507 in
Given a region R that is a non-perfect region defined by two keys k1 and k2, with an m-ary pattern, let the m sub-regions (k11, k12), . . . , (km1, km2) be produced by decomposition of the region according to the pattern be (k11, k12), . . . , (km1, km2), and
then it is easy to show that s2<s1 always holds. It follows that the precision of a non-perfect region is always improved after a DST decomposition. Moreover, DST decompositions have the following properties: (1) any largest perfect region contained in the region is always contained in a sub-region in the result as a whole and will never be partitioned; and (2) there are no other decompositions of the same arity (m) with an overall linear size smaller than s2. In this sense, the DST decompositions according to the corresponding patterns are optimal.
The decomposition of a region <k1,k2>, is performed by the following method, which first identifies the pattern of the region and then calls the corresponding decomposition method:
Given that <s, t> is an non-perfect region, and ρ, a number between 0 and 1, is the desired precision, the following method recursively decomposes the region into sub-regions with precision equal or higher than ρ:
The search of a region in 3D space is therefore a recursive process. A subregion is further decomposed if and only if its precision has not reached the predefined value. The result of the above search is a list of linear regions with precisions equal or higher than the given value of ρ.
There are other ways to control the recursion. One of them depends on the notion of geometric level. Given a regular region <s, t>, and its longest edge along all dimensions l, the regular region has a geometric level of ┌log2(l)┐. It is easy to verify that the geometric and DST levels are equal for a perfect cube at any level, and the former is always smaller than or equal to the latter for any region. The difference between the two levels of a region is thus an indicator to how close the region is to a perfect cube, and as such it can be used to replace the precision ρ in method ΠR for better computing efficiency.
No matter how the value of precision or level difference is chosen, method ΠR always yields a result with 100% recall. The freedom of setting different stopping thresholds for the recursive divide-and-conquer process allows a trade-off between the precision and computing speed, which can be easily exploited for performance optimization.
The result of the search by FIR in the above is a list of disjoint linear subregions with desired precision. The search over a 3D region is thus reduced to the searches over several 1D intervals of the linearly ordered DST key spaces.
Given that S={p={x,y,z}|0≤x≤X; 0≤y≤Y; 0≤z≤Z; X, Y, Z Integers} be a regular 3D space with the length along each dimension equal to X, Y, Z, respectively, and a set of Points of Interest (“POIs”) distributed over the space S, a regional search with respect to the regular region R=<s, t> in S finds each point p s.t. p∈POI and p∈R. It is apparent that the DST key of any point of interest p in the searched region R necessarily falls into one and only one of the linear regions in the list of results returned by method ΠR. The 3D region search thus reduces to a search over a number of intervals corresponding to the linear regions in the Result returned by ΠR.
In the above program for ΠR, when a linear region meets the precision criterion, it is pushed into the Result, and the Result with all the linear regions is returned as a whole by the recursive decomposition. The search for the points of interests in the linear regions is performed as a separate procedure. Alternatively, when a linear region [k1, k2] meets the precision criterion, instead of pushing it into the result list, a search can be immediately started for the DST keys with values falling in the interval [k1, k2] using a data repository (“Repo”) that supports some operations. The operations include Put (Repo, k), which allows DST keys to be inserted in the Repo dynamically, and Get (Repo, u, v), which finds keys in the Repo with values falling between u and v.
There are a variety of data structures which can be adapted to serve purpose, including the well-known sorted list and Red-Black Tree. As will be seen in the following section, a new type of Repo named Black-White Array (“BWA”) is provided as a faster solution to the problem. Unlike any tree-based or list-based approach, a BWA uses arrays as the underlying structure, and thus avoids storing, de-referencing and maintaining pointers and rebalancing the structure.
Since the linear regions by the decomposition with method ΠR are disjoint, the searches over the regions are completely independent of each other, and therefore can be done in parallel. Moreover, the recursive decomposition process can be done in parallel with the search over any so far discovered regions to afford another level of parallelism provided that the computing resources are available.
Nbrs(S, q, r)={p|p∈S, Dist(p, q)≤r}.
On the other hand, the cubical neighborhood of reference point q (602) in the same space refers to:
Nbrc(S, q, r){p|p=(zp, yp, Xp)∈S, |zp−zq|≤r, |yp−yq|≤r, |xp−xq|≤r}.
Let R be a region in a space, U the set of points of interests in R, and V a set of points returned by a search, then the recall of the search is given by
recall=|U∩V|/|U|
while the precision of the search is given by
precision=|U∩V|/|V|
The two metrics are used to measure the performance of a search in terms its completeness and preciseness respectively. Their values are always a number between 0 and 1, by definition. Note that the notion of precision of a region previously introduced is related to but different from precision of a search.
A neighborhood examination over the 3D data set S starts with the DST Transform H that maps each point p in S to a point in an one-dimensional space and puts the ensemble in a data repository Repo, which supports two operations: Put (Repo, k) and Get (Repo, s, t), as stated previously. The method Φ maps a set of points using the transform H and puts the results into a Repo, where w is the width of the binary form for the coordinates along each dimension of the 3D space:
The following method NBR computes the neighborhood Nbrc(S, q, r), with a recall of one and a precision ρ between 0 and 1, that a user can choose properly according to the circumstances of the application, with the operation Put(Repo, k) storing the point p with the key k=H(p) in the Repo while the operation Get(Repo, s, t) retrieves all the points with keys in the closed intervals of [s, t]:
In the above method, S={pn−1, . . . , p0} is a set of points of interest in a 3D space, q=(z,y,x) is the reference point, r is the radius of the neighborhood, ρ is the specified precision. The argument cubic? is a Boolean argument that indicates whether the neighborhood to be searched is cubic or spherical.
Both cubic and spherical neighborhood examination has a recall of 100%. In other words, any point in the region will turn out in the result. The precision of the cubic neighborhood can be controlled by the parameter ρ, which can take any desired value between 0 and 1. A spherical neighborhood can be approximated by the circumscribing cubic neighborhood, if so desired, which yields an expected precision of 52.3598%, assuming uniform distribution of the points in the space. For searches with precision smaller than one, the points falling out the cubic or spherical region can be easily removed from the final result by a filtering process, which simply checks if the points falls within the region. Hence the precision can always be made 100% with a filtering process that takes time linear with the number of points in the search result, even when the search is given a low precision parameter. In general, a search with a reasonably low precision parameter followed by a filtering process is much more efficient than a search with a precision parameter equal to 1 to achieve 100% of precision.
In many problems, it is often desired to find the k nearest neighbors for a given point, particularly for the case k=1. The method Nbrk uses method NBR_c to determine the nearest k neighbors for a given point q in the space S:
For a small neighborhood, Result is generally a small set, hence the cost of sorting is generally low. An alternative to insert the points in the result into a separate Black-White array, which is always segment-wise sorted, as provided in the following section.
Neighborhood examination in 3D space has been mostly performed directly over the space, using methods, denoted Ψ, that are often based on k-d trees. The current methods differ from the conventional approaches in that it uses a transform, written H, to reduce the problem into a problem in the domain of one-dimensional space with special properties. The neighborhood examination is then performed in the transformed domain with the Π method. The results are then transformed back to 3D domain with H−1, the inverse of Φ. In functional notation, the methods in this embodiment can be concisely summarized as Ψ=H−1·Π·H.
Finally, a very fast search method for the nearest neighbor or neighbors of a point by searching the perfect cube of a certain level to which point p resides is provided:
Assuming the DST level of the perfect cube calculated from a desired diameter is Lc, this method ensures that all points within the perfect cube of level Lc to which point p belongs are searched. While the search within the perfect cube has 100% recall, some points which might be closer to the point p than those in the result might not be included. This occurs when the point p resides near the edges or corners of the cube. The impact of this inaccuracy to the precision of the final map of a point cloud is often practically undetectable.
The purpose of point cloud sampling is to reduce the cardinality of the data set. This procedure is generally applied to every new frame of data, such as point cloud collected by LiDar, to reduce the cost of computation. Existing methods include: (1) removing every k-th point from the input with respect to some ordering of the data points; and (2) using an octree to filter out all but one point in each octree cell.
The space can be scaled to keep zero or one point in every perfect cube of level Ls in the DST-transformed space. The following point-cloud-sampling method carries out this compression:
The sub-region defined by keys s and t is always a perfect cube; therefore, this procedure never involves region decomposition. In effect, in functionality, this is equivalent to the sampling by octree. The difference is that the above method uses neither the explicit construction of an octree nor any tree traversals. Even though developed for difference purposes, the above two methods share the basic approach of searching in a perfect cube of a certain level.
Note that a point cloud with negative and/or decimal coordinates can always be shifted and scaled so that all coordinates are positive and integral prior to applying the currently disclosed methods.
The point-cloud search and sampling methods, discussed above, provides order(s) of magnitude improvement in the computational efficiency of point-cloud-registration systems. As discussed above, this represents an enormous improvement in these types of computing systems, both from the standpoint of energy consumption, memory-resource consumption, and real-time performance, moving point-cloud registration from the prototype and research realms into the realm of practical, commercially feasible systems underlying point cloud registration, simultaneous localization and mapping (SLAM), autonomous vehicles and other such real-world applications. The DTS transform, along with the decomposition methods discussed above, can be usefully applied in many problem domains, just as Fourier transforms are used throughout science and technology, from image and signal processing to quantum mechanics and molecular-structure determination.
In this embodiment, the values in a data repository (“Repo”) are assumed to be drawn from a totally ordered set, e.g. the set of integers and/or DST keys. Note that DST keys are positive integers in an 1D space even though they are derived from the coordinates of the points in a 3D space. The operations supported here are (1) Insert v: inserts a value into the Repo; (2) Search v: finding the location inside Repo where the value equal to v, if v exists in the Repo, otherwise return nil; (3) Find (u, v): finds all the values in the Repo that fall in the close interval of [u, v]. The Find operation is motivated by applications such as DST transform, which reduces a 3D regional search to a number of 1D interval searchers,
Data structures with similar operations have long been studied. Examples include linked lists, binary search trees, and quite a number of well know tree based data structures. A salient example among them is the Red-Black Tree.
Black-White Array (“BWA”) is an implementation of the Repo that supports the operations specified above. Unlike any tree-based solutions, BWA is completely array based, and, as such, it has avoided the need for pointer (de-)referencing and rebalancing of the tree, and thus, has saved the associated space and time cost.
A BWA with a capacity of N=2k consists of a pair of arrays Black (“B”) and White (“W”) of sizes N/2 and N, respectively. The entries in the B(W) array are indexed by indices ranging from 1 to (N/2)−1 (N). Both the B and W arrays are conceptually divided into segments of different ranks, where segment i contains entries with indices in the interval of [2i, 2i+1−1]. It follows that for a BWA of capacity of N=2k, the W (B) array has a total of k (k−1) segments, and a segment of rank r holds exactly 2r entries.
In the following, Segw(i) and Segb(i) denote the segments of rank i in the White and Black arrays respectively. A segment is said to be occupied if it is filled with inserted value(s). By definition, the highest index in Seg(i), written S(i), is given by 2(i+1)−1=1<<(i+1)−1, where “<<” is the left shift of the binary representation of an integer. The lowest index in Seg(i), written as T(i), is given by 2i=1<<i. The highest and lowest indices of a segment are referred to respectively as the starting (s) and terminating (t) positions of the segment.
The insert operation is performed by the following simple and recursive rules: (1) a new value is always inserted into Segw(0) if it is not occupied, otherwise inserted into Segb(0); (2) for any rank i, whenever Segw(i) Segw(i) are both occupied, they will be merged as one sorted sequence, and put into Segw(i+1) if it is not occupied, otherwise, put into Segb(i+1).
Note that the “merge” above assumes two sorted sequences of the same length, and merge them into one of doubled length. In functionality, it is exactly the same as that in the well-known merge sort.
To adhere the above rules, the occupancy of the white segment of a given rank is determined. It turns out that this can be done by simply tracking the total number of values inserted. Let t be that number. Set t=0 for a new BWA, and, whenever a new value is inserted, we set t=t+1. It can then be easily proved, given the rules stated above, that Segw(i) is occupied if and only if the ith least significant bit oft is one.
More formally, the Insert of a value v into the BWA is given below:
where t is the total number of value(s) stored int the BWA; The function merge is called which merges black and white segments of a given rank with possible recursion(s) as defined by
It follows from the rules of BWA insertion that whenever the total number of inserted values is a power of two, t=2m, all the values will appear in the BWA's white segment of rank m as a sorted sequence. It can also be easily proven this sorting procedure by insertion with BWA takes exactly the same number of comparisons as the well-known merge sort.
Observe that the values left in the lower ranked segments after a merge will not affect the correctness of further BWA operations, and therefore there is no need to spend the time to remove them. For example, after the insertion and merge process illustrated by
The Search operation takes a value v and a rank i and searches through Segw(i). If the value is found, the Search operation returns the index of the value, and, otherwise, returns nil. As can be seen in the definition below, it is no more than a simple binary search:
Having the search over an individual segment defined, a search over the entire BWA is now straightforward. Note that the first letter of its name is capitalized to distinguish it from the search operation over one segment.
where t is the total values stored in BWA, N is the capacity of the BWA, and k=log N is the logarithm of N which is equal to the rank of the longest white segment in the BWA. Note that the search started with the white segment of highest rank of the largest size, and moves to the next occupied segment of lower rank only if the value is not found. It terminates successfully when the first index holds the value is found, or terminates unsuccessfully if the value does not exist in the BWA after all the occupied white segments are searched. Observe that an unoccupied segment would never be examined in the search process, and the occupancy of a segment i can be easily determined by looking at the ith significant bit of the total tin binary form.
The function findUb(s, t, v) (FindLb(s, t, v)) is similar to the search above. It finds the upper (lower) bound index j for the value of v. This is to say that j is the greatest (smallest) index j such that any entry with index smaller (greater) than j is equal or smaller (greater) than v. Note that findUb (findLb) would be unsuccessful (returning −1) when the smallest (largest) value between index s and index t is greater (smaller) than v. The method FindUb is next provided. The method FindLb is similarly constructed:
The search for values sitting between the 1D region [u, v], u>=v, in the white region of rank i, can now be implemented by:
The following operation Find(u, v) is used to find all the values between [s, t] in the entire BWA:
In the previous section of Neighborhood Examination, operations Put(Repo, k) and Get(Repo, s, t) are referred to in methods Φ and Nbr to support 3D regional and neighborhood search based on DST. At this point, it should become clear that a BWA can be the designated Repo and that the BWA's Insert(k) and Find(u, v) methods be used to realize the Put and Get operations.
Unlike k-d tree, octree or other tree-based approaches, regional and neighborhood searches in a 3D-space based on the DST transform avoid construction, traversal, and balancing of any tree structure. The recursive decomposition works directly on the region with a time independent of the cardinality of the entire space. The precision of the DST based search generally reaches a fairly high level with a shallow depth of recursive space decomposition and with a guaranteed recall of 100 percent. The testing of the DST based methods against other state-of-art methods with public 3D data sets and point clouds has demonstrated an order-of-magnitude improvement in speed over other current methods. The BWA data repository subsumes, in functionality, both the static sorting methods, such as merge-sort, and the dynamic 1D search structures, such as the red-black tree. The BWA data repository has the flexibility of building the repository incrementally that the former lacks and avoids the cost of construction, maintenance and balance of a tree structure that the latter suffers. The joint use of DST and BWA makes the real time processing in time-critical applications, such as point cloud registration for autonomous driving, an achievable task with reasonable computational resources.
This application is a continuation-in-part of U.S. Pat. No. 10,580,114, issued Mar. 3, 2020, which claims the benefit of Provisional Application No. 62/478,422, filed Mar. 29, 2017.
| Number | Name | Date | Kind |
|---|---|---|---|
| 20100174721 | Mou | Jul 2010 | A1 |
| 20130297574 | Thiyanaratnam | Nov 2013 | A1 |
| 20160117856 | Chang | Apr 2016 | A1 |
| 20180081995 | Horhammer | Mar 2018 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20220277414 A1 | Sep 2022 | US |
| Number | Date | Country | |
|---|---|---|---|
| 62478442 | Mar 2017 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 15940789 | Mar 2018 | US |
| Child | 16807494 | US |
