Bounding method for spatial data

Abstract

The present invention discloses a computer-implemented method for bounding spatial data, where the spatial data is associated with the geometric boundaries of items mapped to one or more axis-aligned 3D bounding boxes. The geometric boundaries are in each permutation of all possible positions of the geometrically upper-bounded items. The method includes first dividing a set of bounding boxes along the x-axis direction using a first set of intervals and assigning a division identifier xpar; then dividing the set of bounding boxes along the y-axis direction using a second set of intervals and assigning a division identifier ypar; then dividing the set of bounding boxes along the z-axis direction using a third set of intervals and assigning a division identifier zpar; and then dividing the set of bounding boxes by a division identifier tuple (xpar, ypar, zpar). Preferably, the bounding boxes having the same division identifier tuple will be merged.

Description

Technical Field

[0001] The present invention relates to a computer-implemented method for bounding spatial data associated with the geometric boundaries of items mapped to one or more axis-aligned 3D bounding boxes, and in particular, the geometric boundaries bound the geometry for each permutation of all possible positions of the items. Background Art

[0002] Computer-aided design (CAD) tools are frequently used in the manufacture of complex products. Within the software, these products are typically represented as a hierarchical product structure, often displayed in the form of a product tree. This allows users to query the product structure in a simple way to view or edit the parts and part assemblies stored within the product structure. Over time, these parts and part assemblies will undergo multiple modifications, which requires configuration to produce a manufacturable product. For example, in automotive manufacturing, a wheel requires several wheel bolts to secure it to an axle, the wheel itself can be a front wheel, rear wheel, left wheel, or right wheel, the axle will be mounted to a chassis, and the chassis is connected to a vehicle model, etc. This represents a case where the product tree between the root (the vehicle) and the final item (the wheel bolt) is relatively short, but for a fully configured, manufacturable product, each wheel bolt needs to have its own branch in the product structure tree. Since each branch must be configured whether or not it is displayed to the user, the size of the configured product obtained can be quite large.

[0003] To modify, operate on, or make selections on the root product (the vehicle in this example), the user needs to be able to search for events of parts and part assemblies, individual parts, or part modifications within the product structure. Depending on the amount of data involved, searching and configuring such a product structure can be slow, and is typically improved by using caches of the configured product and expanding the events of parts and part assemblies. However, the caching methods for such configured products have several drawbacks. First, each individual configuration of the product requires a separate cache. Each cache needs to be stored and kept up-to-date. Second, the change management process results in change-specific, user-specific, and group-specific configurations of the product. This increases the number of caches required. Finally, historical configurations also require separate caches for each historical point, regardless of the number of modifications made. This further increases the number of caches required. Alternative methods include, for example, techniques for database indexing of paths in the product structure, which, while an improvement over the caching method, is only effective for a short period of time. Over a longer period, modifications made to parts and part assemblies can trigger a path explosion. This can be limited by indexing the most recent changes within a short time range, but this may be impractical or undesirable for the user.

[0004] One solution to this problem is to use an unconfigured product structure index. As the name implies, this is an index that uses item paths to store the structure, rather than an index that stores multiple combinations of fully configured products and the parts, components, and subcomponents required to build that product. When a part is repeated in a component, such as the five wheel nuts in a wheel, only one item path needs to be stored compared to five separate wheel nut entries in a conventional product index. This greatly simplifies the index. However, in some cases, although the actual parts may be the same, the position of the parts in the same product may be different. Taking the wheel nut as an example, each nut is positioned at a different location on the wheel hub. To reflect this phenomenon, the unconfigured product structure index can store the unconfigured geometric boundaries associated with the item path as one or more axis-aligned 3D bounding boxes. This enables the index to support spatial queries. The geometric boundaries must account for every permutation of all possible positions of the geometrically upper-bounded part, including:

[0005] ● Changes in the geometric boundaries of the part when the part is modified;

[0006] · Different positioning transformations for each instance of the part in the component;

[0007] ● Different positioning transformations for each instance of the component in the parent component;

[0008] · Changes in the positioning transformation when the component is modified.

[0009] Storing the complete permutations may take up a large amount of storage space and / or require a long query time, even if exact duplicates have been removed. Overall and after multiple modifications (e.g., making the part stronger or lighter), it is expected that the numerical changes in the geometric boundaries of the part and / or component positioning transformations in the product are small. Over the component life cycle, the positioning transformation may also change slightly due to, for example, numerical rounding or part tolerances. These differential permutations may result in many similar, overlapping geometric boundaries. However, in the above example, the geometric boundaries are unconfigured, i.e., not yet configured with the part into a specific component or product. Similar problems would occur for configured geometric boundaries. If the number of configured geometric boundaries associated with a configured product index is given, long query times and large storage requirements are still expected because all complete permutations of the geometric boundaries must be stored.

[0010] While a simple solution is to bound the complete permutations with a single boundary, since this solution is easy to implement and compact in storage, this solution produces too many false positives when querying the index. Some index entries may have many different positions because small parts may be used in many widely dispersed positions, such as the wheel bolt example given above. Thus, it is necessary to avoid having so many false positives and at the same time maintain the ease of implementation and efficient storage of the solution. Summary of the Invention

[0011] The present invention aims to solve these problems by providing, in a first aspect, a computer-implemented method for bounding spatial data, wherein the spatial data is associated with the geometric boundaries of items mapped to one or more axis-aligned 3D bounding boxes, the geometric boundaries geometrically bounding each permutation of all possible positions of the items, the method comprising the steps of:

[0012] a) Divide the set of bounding boxes along the x-axis direction using a first set of intervals and assign a partition identifier xpar;

[0013] b) Divide the set of bounding boxes along the y-axis direction using a second set of intervals and assign a partition identifier ypar;

[0014] c) Divide the set of bounding boxes along the z-axis direction using a third set of intervals and assign a partition identifier zpar; and

[0015] d) Divide the set of bounding boxes by a partition identifier tuple (xpar, ypar, zpar).

[0016] Embodiments of the present invention provide the following advantages, namely, saving the geometric boundaries without the need to store the complete permutations, thereby reducing the false positives that occur during spatial queries while maintaining a small storage space requirement and a fast query time. For large values of n, each sorting process associated with an embodiment of the present invention takes time proportional to n.log(n), where n is the number of items being sorted.

[0017] Preferably, the method further comprises the steps of:

[0018] e) Identify any group of bounding boxes in the set that have the same partition identifier tuple and merge the bounding boxes in the group.

[0019] Preferably, the format of each bounding box is [xmin, ymin, zmin; xmax, ymax, zmax], such that when xmin ≤ x ≤ xmax, ymin ≤ y ≤ ymax and zmin ≤ z ≤ zmax, the geometric point [x, y, z] lies within or at the boundary of the box.

[0020] Preferably, partitioning the set of bounding boxes along the x-axis, y-axis, or z-axis directions includes the following steps:

[0021] i) Project each bounding box in the set onto the axis direction to form a 1D interval from the 3D bounding box;

[0022] ii) Sort the 1D intervals in ascending order of xmin, ymin, or zmin values or descending order of xmax, ymax, and zmax values; and

[0023] iii) Traverse the 1D intervals in ascending or descending order and assign partition identifiers xpar, ypar, or zpar to each 1D interval respectively.

[0024] Preferably, partitioning the set of bounding boxes by the partition identifier tuple (xpar, ypar, zpar) further includes the following step: sorting the partition identifier tuple in lexicographical order.

[0025] Preferably, the merged axis-aligned bounding box is the axis-aligned minimum bounding box. Preferably, the axis-aligned minimum bounding box contains the minimum value of each of xmin, ymin, and zmin and the maximum value of each of xmax, ymax, and zmax of the bounding boxes forming the bounding box group, and the bounding boxes forming the bounding box group have the same partition identifier tuple.

[0026] The method may further include the step of additionally partitioning the set of bounding boxes using the same or different groups of intervals before assigning the partition identifier tuple. In this case, preferably, the additional partitioning is repeated until a predetermined end point is reached. Preferably, the predetermined end point is either a set of spatial index targets or a set of temporal index targets, or only a single bounding box is retained within the bounding box group. Alternatively, before partitioning the bounding boxes, the intervals can be modified to increase or decrease the number of bounding boxes with the same partition identification tuple. In this case, the intervals can be expanded, shrunk, or transformed.

[0027] Preferably, the geometric boundary is unconfigured. In this case, preferably, the spatial data is associated with the item path of an entry in the unconfigured product index.

[0028] In a second aspect, the present invention also provides a computer program including instructions that, when executed by a computer, cause the computer to perform the steps of the method.

[0029] In a third aspect, the present invention also provides a data processing device including a processor adapted to perform the steps of the method. Detailed Description

[0030] The present invention will now be described only by way of example. The present invention preferably but not always employs a method of using a partitioning technique in conjunction with a merging step in order to provide a computer-implemented method for bounding spatial data associated with the geometric boundaries of an item. Such geometric boundaries are mapped to one or more axis-aligned 3D bounding boxes, and each permutation of all possible positions of the item is geometrically bounded. First, a step of partitioning a set of bounding boxes along the x-axis direction using a first set of intervals and assigning a partition identifier xpar is performed. Next, a step of partitioning the set of bounding boxes along the y-axis direction using a second set of intervals and assigning a partition identifier ypar is performed. Then, a step of partitioning the set of bounding boxes along the z-axis direction using a third set of intervals and assigning a partition identifier zpar is performed. Finally, a step of partitioning the set of bounding boxes by a partition identifier tuple (xpar, ypar, zpar) is performed. If the partitioning step is coupled with the merging step, then any group of bounding boxes in the set having the same partition identification tuple is identified and the bounding boxes in the group are merged. This has a primary use when the geometric boundaries are unconfigured and in creating an index of an unconfigured product structure. Omitting the merging step has a primary use in examining an index of an unconfigured product structure. The format of the bounding box itself is [xmin, ymin, zmin; xmax, ymax, zmax], such that when xmin ≤ x ≤ xmax, ymin ≤ y ≤ ymax, and zmin ≤ z ≤ zmax, the geometric point [x, y, z] lies within or on the boundary of the box. The basis of the present invention is to eliminate the need to store all permutations of geometric boundaries, and thus, although the examples given below are with respect to unconfigured geometric boundaries, the principles of partitioning and merging bounding boxes still apply.

[0031] Interval and interval partitioning

[0032] First, an embodiment of the present invention requires partitioning a set of bounding boxes along a given axis direction. To this end, the initial step is to project the bounding boxes onto that axis direction in order to form 1D intervals from the 3D bounding boxes. For a bounding box [xmin, ymin, zmin; xmax, ymax, zmax], the x interval will be [xmin, xmax], the y interval will be [ymin, ymax], and the z interval will be [zmin, zmax]. Consider the following bounding box as an example:

[0033] [0, 0, 0, 10, 3, 1]

[0034] When projected onto the x-axis direction, it yields [0, 10], when projected onto the y-axis direction, it yields [0, 3], and when projected onto the z-axis direction, it yields [0, 1]. Once the projection is completed, the 1D intervals [min, max] must be sorted in the selected order. In this example, the 1D intervals are sorted in ascending order of the lower limit value min. However, it may be preferred or desired to sort the 1D intervals in descending order of the upper limit value max. Take the following intervals as an example:

[0035] [5, 6], [0, 1], [10, 11], [5, 7]

[0036] Their possible order is:

[0037] [0, 1], [5, 7], [5, 6], [10, 11]

[0038] Among them, the relative order of the intervals [5, 6] and [5, 7] with equal lower limit values min is not important because it does not affect the end point of the order. Similarly, if it is desired to sort in descending order of the upper limit value max, the order obtained will be:

[0039] [10, 11], [5, 7], [5, 6], [0, 1]

[0040] Once the sorting is completed, the next stage is to traverse the 1D intervals in ascending (or descending, as applicable) order and assign integer partition identifiers. Here, overlapping intervals will have the same identifier. Again, using the sorting based on ascending order of the lower limit value min, the traversal process needs to iteratively pass through the 1D intervals in the sorted order and track the "high-water mark" of the upper limit value, corresponding to the maximum value of the upper limit value max. Therefore, starting from the sorted list:

[0041] [0, 1], [5, 7], [5, 6], [10, 11]

[0042] The first interval (with the smallest lower limit value min) is [0, 1]. The partition identifier xpar assigned to this interval is 0, and the high-water mark is 1. The next interval is [5, 7], which is above the high-water mark 1, and thus is assigned a new partition identifier 1. The new high-water mark is 7. The next interval is [5, 6], which is not above the high-water mark (because 6 is less than 7), so it is also assigned the partition identifier 1. Finally, the interval [10, 11] is above the high-water mark 7, so it is assigned a new partition identifier 2, and the new high-water mark is set to 11.

[0043] In fact, traversing the sorted intervals is to determine the gaps and start a new partition whenever a gap is found. The same applies when using the reverse method (i.e., sorting the intervals with the descending upper limit value max), and then using the low-water mark (the minimum value of min) to assign partition identifiers.

[0044] Repeat this process for the y-axis and z-axis, and assign the values of xpar, ypar, and zpar. Thus, each bounding box is represented by a tuple of partition identifiers [xpar, ypar, zpar].

[0045] Using irregular grid partitioning

[0046] In the next step of the method, once the partition identifiers have been assigned and the bounding boxes are represented by tuples of partition identifiers, it is necessary to divide the bounding boxes by the tuples of partition identifiers. For example, the following three bounding boxes

[0047] i) [0, 0, 0, 10, 10, 10]

[0048] ii) [5, 15, 0, 15, 25, 10]

[0049] iii) [5, 0, 0, 15, 10, 10]

[0050] have x partition identifiers xpar: 0, 0, and 0; y partition identifiers ypar: 0, 1, and 0, and z partition identifiers zpar: 0, 0, and 0. This results in the following partition identifiers:

[0051] xpar: 000

[0052] ypar: 010

[0053] zpar: 000

[0054] And, therefore, the following tuples of partition identifiers are generated:

[0055] i) (0, 0, 0)

[0056] ii) (0, 1, 0)

[0057] iii) (0, 0, 0)

[0058] Then, these partitioning identification tuples are sorted in lexicographical order to group together identical tuples: i) and iii) together, ii) alone. As long as the sorting criteria are consistent, the choice of sorting criteria does not matter. For example, we can sort by xpar, then by ypar for those with the same xpar, and then by zpar for those with the same xpar and ypar. This will group together the same (xpar, ypar, zpar) values. Using the irregular grid method effectively makes it possible to form a grid with irregular dimensions around the bounding box such that each plane in the grid touches at least one bounding box but does not intersect any bounding box. Each bounding box exactly occupies one grid cell, and each occupied cell has a partitioning identification tuple label (xpar, ypar, zpar). Thus, traversing the individual intervals is equivalent to traversing the planes in each of the x, y, and z axis directions.

[0059] Merging bounding boxes

[0060] So far, the method is suitable for sorting an unconfigured product structure index to check whether certain bounding boxes exist in the index. However, to create unconfigured spatial boundary elements of the unconfigured product structure index, the next stage is to merge the bounding boxes that share the same partitioning identification tuple. Taking the above boxes i), ii), and iii), for the partitioning identification tuple (0, 0, 0), boxes i) and iii) will be merged. Merge the bounding boxes located in the grid cells. This is done by creating an axis-aligned minimum bounding box, where the axis-aligned minimum bounding box contains the minimum of each of the xmin, ymin, and zmin of the bounding boxes and the maximum of each of the xmax, ymax, and zmax of the bounding boxes, and the bounding boxes form a group of bounding boxes with the same partitioning identification tuple. For the above bounding boxes i) and iii), this results in a single bounding box:

[0061] [0, 0, 0, 15, 10, 10]

[0062] No other bounding box shares the same partitioning identification tuple as box ii), so bounding box ii) remains unchanged.

[0063] Repeated partitioning of bounding boxes

[0064] In some cases, it may be desirable to repeat the partitioning step for the bounding box group because a single partitioning step may result in a large bounding box group sharing the same partitioning identification tuple. Smaller bounding box groups may have different options for merging into larger bounding box groups, so it may be preferable to perform the partitioning process until a predetermined end point is reached. This predetermined end point is either a set of spatial index targets or a set of temporal index targets, or only a single bounding box is retained within the group. This effectively enables the use of the same or different interval groups to repartition the set of bounding boxes before assigning the partitioning identification tuple. For example, the bounding boxes:

[0065] iv) [0, 0, 0, 1, 1, 1]

[0066] v) [2, 0, 0, 3, 1, 1]

[0067] vi) [0, 2, 0, 3, 3, 1]

[0068] are grouped as follows:

[0069] Partitioning identification tuple (0, 0, 0) - bounding boxes iv) and v)

[0070] Partitioning identification tuple (0, 1, 0) - bounding box vi)

[0071] Taking the first partitioning and repartitioning gives the sub-partitioning identification tuple (0, 0, 0) for box iv) and the sub-partitioning identification tuple (1, 0, 0) for box v). The repartitioning causes box iv) to have intervals [0, 1], [0, 1], and [0, 1] along x, y, and z respectively, and box v) to have intervals [2, 3], [0, 1], and [0, 1] along x, y, and z respectively. Performing the above sorting process and assigning sub-partitioning identifications in the same way results in sub-partitioning identification tuples.

[0072] Adjacent and nearby bounding boxes

[0073] When rotating parts during product design, the required transformations may not always maintain the axis-aligned property of the original bounding box, or there may be floating-point rounding errors, geometric tolerances, and positioning tolerances inherent in the product, resulting in bounding box expansion. This means that two adjacent bounding boxes may not be precisely adjacent. To address this issue and ensure that the bounding boxes can be successfully merged, the intervals can be modified to increase or decrease the number of bounding boxes with the same partitioning identification tuple. This can be achieved by intervals that are expanded, shrunk, or transformed. For example, take two bounding boxes:

[0074] vii) [1, 1, 1, 1.99999999, 2, 2]

[0075] viii) [2, 1, 1, 3, 2, 2]

[0076] There is a small (0.00000001) gap between them in the x-axis direction. Slightly different bounding boxes are divided from the original bounding box to enable control of grouping - this can allow the merging of bounding boxes with a 10% gap, or avoid the merging of bounding boxes with a 10% overlap. Taking bounding boxes vii) and viii) and expanding them by 10% in each direction will result in:

[0077] vii)' [0.90000001, 0.9, 0.9, 2.099999989, 2.1, 2.1]

[0078] viii)' [1.9, 0.9, 0.9, 3.1, 2.1, 2.1]

[0079] These changed bounding boxes now overlap and have partition identification tuples (90, 0, 0) and (0, 0, 0). Merging the original boxes results in a single box [1, 1, 1, 3, 2, 2]. Thus, if bounding boxes with an n% gap are merged, the interval is expanded by n% before assigning the partition identification. If there are numerical inaccuracies or tolerances, the interval is expanded by the corresponding inaccuracy or tolerance value.

[0080] Preferably, the method is performed by a computer program and / or by using a data processing device.

Claims

1. A computer-implemented method for bounding spatial data, the spatial data being associated with the geometric boundaries of items mapped to one or more axis-aligned 3D bounding boxes, the geometric boundaries geometrically bounding each permutation of all possible positions of the items, wherein, The spatial data is associated with the item paths of entries in an unconfigured product index, and the method includes the following steps: a) Divide the set of bounding boxes along the x-axis direction using a first set of intervals and assign a division identifier xpar; b) Divide the set of bounding boxes along the y-axis direction using a second set of intervals and assign a division identifier ypar; c) Divide the set of bounding boxes along the z-axis direction using a third set of intervals and assign a division identifier zpar; and d) Divide the set of bounding boxes by a division identifier tuple (xpar, ypar, zpar), wherein the format of each bounding box is [xmin, ymin, zmin; xmax, ymax, zmax], such that when xmin ≤ x ≤ xmax, ymin ≤ y ≤ ymax, and zmin ≤ z ≤ zmax, the geometric point [x, y, z] lies within or on the boundary of the bounding box, wherein dividing the bounding boxes along the x-axis, y-axis, or z-axis directions includes the following steps: i) Project each bounding box in the set onto the axis direction to form 1D intervals from the 3D bounding boxes; ii) Sort the 1D intervals in ascending order of the values of xmin, ymin, or zmin or in descending order of the values of xmax, ymax, and zmax; and iii) Traverse the 1D intervals in ascending or descending order and assign a division identifier xpar, ypar, or zpar to each 1D interval respectively.

2. The method according to claim 1, wherein, The method further includes the following steps: e) Identify any group of bounding boxes in the set that have the same division identifier tuple and merge the bounding boxes in the group of bounding boxes.

3. The method according to claim 1, wherein, Dividing the set of bounding boxes by a division identifier tuple (xpar, ypar, zpar) further includes the following steps: Sort the division identifier tuple in lexicographical order.

4. The method according to claim 3, wherein The merged axis-aligned bounding boxes are axis-aligned minimum bounding boxes.

5. The method according to claim 4, wherein The axis-aligned minimum bounding box contains the minimum value of each of xmin, ymin, and zmin and the maximum value of each of xmax, ymax, and zmax of the bounding boxes forming the group of bounding boxes, and the bounding boxes forming the group of bounding boxes have the same division identifier tuple.

6. The method according to any one of claims 2 to 5, wherein The method further includes the following steps: additionally divide the set of bounding boxes using the same or different groups of intervals before assigning the division identifier tuple.

7. The method according to claim 6, wherein Repeat the additional division until a predetermined end point is reached.

8. The method according to claim 7, wherein The predetermined end point is either a set of spatial index targets or a set of time index targets, or only a single bounding box is retained within the group of bounding boxes.

9. The method according to any one of claims 2 to 5, wherein Before dividing the bounding boxes, modify the intervals to increase or decrease the number of bounding boxes with the same division identification tuple.

10. The method according to claim 9, wherein, The intervals are expanded, contracted, or transformed.

11. The method according to claim 1, wherein, The geometric boundary is unconfigured.

12. A computer program product, the computer program includes instructions that, when the computer program product is executed by a computer, cause the computer to perform the steps according to any one of claims 1 to 11.

13. A data processing device comprising a processor adapted to perform the steps according to any one of claims 1 to 11.