JP2820894B2 - Convex polyhedron generator for interference check system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an interference check system for checking interference between a non-convex polyhedron and another object .
The present invention relates to a convex polyhedron creating apparatus , and more particularly to a convex polyhedron creating apparatus that divides a polygon set constituting a non-convex polyhedron into a plurality of polygon subsets having a convex relationship to generate a convex polyhedron . More specifically, the present invention determines an unevenness in each region of an arbitrary three-dimensional CAD model constructed in a graphic workstation or the like, thereby converting an initial model into a finite number of convex objects. BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a convex polyhedron creating apparatus that automatically decomposes into sets, and relates to a technique for generating a convex polyhedron necessary for realizing a real-time interference check system that rapidly checks an interference state between three-dimensional CAD models.

[0002]

2. Description of the Related Art In a real-time interference check system for checking the interference state between three-dimensional CAD models at a high speed, the hitherto known interference check methods limit the object to a convex object. For example, the Boblow method (A Dir
ect Minimization Approach for Obtaining the Distan
ce between Convex Polyhedra., The International J
ournal of Robotics Research, Vol.8, No.3, pp.65-7
6), Lin / Carry method (A Fast Algorithm for Incremental
Distance Calculation., Proceeedings of the 1991 I
EEE InternationalConference on Robotics and Automa
tion, pp. 1008-1014, 1991), Gilbert method (A Fast Proc
edure for Computing the Distance Between Complex O
bjects inThree-Dimensional Space., IEEE Journal of
Robotics and Automation, Vol.4, No.2, pp.193-203,
1988). Each of these methods has a computational load of O
The closest approach point can be calculated in a calculation time equal to or less than (N) (0 () is a function representing a calculation load, and N is the total number of grid points of the object). However, objects to which these methods can be applied are all limited to convex polyhedrons.

On the other hand, commercially available three-dimensional CA such as Pro / Engineer
In most cases, the shape data designed using the D system is a non-convex object. Therefore, real-time interference check methods such as the Boblow method, Lin / Carry method, and Gilbert method cannot be applied to perform interference check between parts. A method of performing a brute force interference check and a method of solving an equation defining a shape by taking time analytically have been adopted.

[0004]

As described above, conventionally, there has been a problem that interference check between the non-convex polyhedron and another object cannot be performed at high speed. Conventionally, there has been a problem that an interference check method having a real-time property, such as the Gilbert method, cannot be applied to an interference check between a non-convex polyhedron and another object. Accordingly, a first object of the present invention is to provide an interference check system for generating a convex polyhedron by decomposing a polygon set constituting a non-convex polyhedron into a plurality of polygon subsets having a convex relationship.
An object of the present invention is to provide a convex polyhedron forming apparatus for a stem . A second object of the present invention is to enable high-speed interference check between a non-convex polyhedron and another object .
A third object of the present invention is to make it possible to apply an interference check method, such as the Gilbert method, having real-time properties when checking interference between convex polyhedrons .

[0005]

FIG. 1 is a diagram illustrating the principle of the present invention. 1 is a set of polygons constituting a non-convex polyhedron,
2 is a means for dividing the polygon set into first and second two groups, 3a and 3b are first and second divided polygon sets, and 4a and 4b are convex and convex in the first and second groups. Means for grouping into certain polygon subsets, 5
Is a merging means for merging (merging) polygon subsets of the first and second groups having a convex relationship, and 6 is a plurality of polygon subsets having a convex relationship in the non-convex polyhedron.

[0006]

A large number of convex polygons (polygons) 1 constituting a non-convex polyhedron are divided into first and second groups 3a and 3b by a dividing means 2, and the groups 3a and 3b are divided by grouping means 4a and 4b. In step 3b, a polygon subset having a convex relationship with the adjacent polygon is obtained. Next, the merging means 5 merges the polygon subsets of the first group and the polygon subset of the second group having a common boundary ridge in a convex relationship to obtain a plurality of new polygon subsets 6. Output (Divide and Conquer Metho
d). In the divide-and-conquer method, the merging means 5 determines whether or not the polygon subset of the first group and the polygon subset of the second group have a convex relationship as follows. That is, all combinations of polygons sharing a boundary ridge are obtained, and when the polygons have a convex relationship in all combinations, it is determined that the polygon subset of the first group and the polygon subset of the second group have a convex relationship. If even one set has a concave relationship, it is determined that there is no convex relationship. In this way, the initial polygon set of the non-convex polyhedron can be quickly divided into polygon subsets of convex elements, and an interference check method such as the Gilbert method having real-time property can be applied at the time of interference check.

The merging possibility in the divide-and-conquer method is checked for interference between convex objects formed by boundary edges of each polygon subset, and if they do not interfere, it is determined that there is no common boundary edge. The following merging possibility processing is skipped, and when interference occurs, it is determined that a common boundary ridge exists, and the subsequent merging possibility processing is continued. In this way, the time required for the merging possibility determination process can be reduced, and the polygon subset for each convex element can be obtained at a higher speed. Further, the convex decomposition processing based on the division and conquer method is repeatedly applied to a plurality of polygon subsets obtained by the convex decomposition processing based on the divide and conquer method. If you do this,
It can be divided into the minimum number of convex elements (the local minimum of the number of convex elements can be obtained).

When the non-convex polyhedron has a negative shape (negative object) such as a hole, the sign of the normal vector of each convex polygon (polygon) constituting the non-convex polyhedron is inverted to form an inverted shape. Is assumed, and a large number of polygons constituting the inverted shape model are divided into two groups, and then a polygonal subset of negative objects is obtained by applying a division and conquer method. Thereafter, the polygon subset of the negative object is removed from the initial polygon set constituting the non-convex polyhedron, and the polygon set of the regular object is applied to the non-inverted polygon set obtained by the removal by applying the divide and conquer method. A subset is obtained, and each positive and negative polygon subset is output. In this way, even when a negative object such as a hole exists in the non-convex polyhedron, the non-convex polyhedron can be divided into a convex polyhedron including the negative object.

[0009]

【Example】

(A) First Embodiment of the Present Invention (a) System Configuration FIG. 2 is a system configuration diagram in a case where a shape model on a graphic workstation is subjected to interference check preprocessing.
The CPU is a processor that executes interference check pre-processing, interference check processing, and other processing, and the MEM is a memory that stores shape data FDT designed by a three-dimensional CAD system (not shown), an interference check pre-processing program ICP, and the like. , DPL is a display unit, OPS is an operation unit such as a keyboard and a mouse, and OPR is an operator. The operator OPR inputs a pre-processing command to the shape model on the graphic workstation GWS using the operation unit OPS. When the pre-processing command is input, the processor CPU performs pre-processing (division processing of the polygon set of the non-convex polyhedron) using the non-convex polyhedron shape data FDT based on the interference check pre-processing program ICP stored in the memory MEM. ). Then, the division result is stored in the memory MEM, and the preprocessing result is presented to the operator through the display unit DPL.

(B) Outline of interference check pre-processing FIG. 3 is a schematic processing flow of the interference check pre-processing according to the present invention. The 3D CAD system creates a shape model (non-convex polyhedron) and creates a graphic workstation GW
Input to S (steps 1001, 1002). CAD
The system inputs all polygon data when the object (non-convex polyhedron) is covered with polygons. The polygon data has information indicating the coordinate value of each vertex of the polygon and the light reflection direction at that point. The most common polygon data is represented by a combination of triangular polygons as shown in FIG. In the case of the triangular polygon data shown in FIG. 3, three real numbers following normal indicate the light reflection direction, and three real numbers following vertex indicate the vertex coordinate values. A procedure for outputting polygon data from a shape model in a three-dimensional CAD system is usually prepared in the three-dimensional CAD system. Then, the polygon data is divided into sets of polygon data (polygon subsets) divided for each convex element according to a basic algorithm for convex decomposition by the divide and conquer method. That is, the initial polygon data (a polygon set of a non-convex polyhedron) is divided into sets of subsets for each convex element and output (steps 1003 and 100).
4). Thereafter, a convex polyhedron is generated for each subset.
Although each shape of the polygon is generally arbitrary, it is assumed that each polygon satisfies convexity.

(C) Basic Algorithm for Convex Decomposition by Divide and Conquer FIG. 4 is a flowchart of a basic algorithm for convex decomposition by divide and conquer. An initial polygon set (polygon set of a non-convex polyhedron) P is input (step 1101), and the initial polygon set P is subjected to processing by the divide and conquer method (step 1102). That is, the initial polygon set P
Is divided into first and second groups, and a polygon subset having a convex relationship with adjacent polygons in each group is obtained. Next, the polygon subsets of the first group and the polygon subset of the second group having a common boundary ridge are merged in a convex relationship to form a plurality of new polygon subsets DP1, DP2,.・ ・Then, the polygon subsets DP1, DP2,.
Is output (step 1103).

The following is a detailed program example of the divide and conquer method. Define _{P = {p 1, p 2} , p 3, ···}: initial polygon set DC (P) = {DP1 = {1 p 1, 1 p 2, 1 p 3, ···}, DP2 = { ₂ p ₁ , ₂ p ₂ , ₂ p ₃ ,...},...｝: P divided polygon set NoP: Number of elements of P Algorithm (divided and conquer method) if (input polygon number is 1, ie, NoP = 1) then DC (P) = P else DIVIDE: k = [number of elements of P / 2] PL = {p ₁ , p ₂ , p ₃ ,..., P _k }: polygon set below k PH = {P _{k + 1} , p _{k + 2} , p _{k + 3} ,..., P _NoP }: polygon set larger than k RECUR: Costruct DC (PL) and DC (PH) recursively. MERGE: Merge DC (PL) and DC (PH) DC (P) = Merge (DC (PL), DC (PH)) endif As can be seen from the above algorithm, in the divide-and-conquer method, the process of division and consolidation is recursively repeated. The most important place where the problem dependency exists in the divide-and-conquer method is the "merging" process, that is, how to construct the function Merge.

(D) Merge process in the divide-and-conquer method FIG. 5 is a flowchart of the Merge process in the divide-and-conquer method. 1) Prepare convex element set DC (PL), DC (PH)
(Steps 1111a and 1111b). Convex element set DC
(PL) and DC (PH) are CLi and C in FIG.
A set of polygons (polygons) constituting the element as shown by Hj and a set of boundary edges forming the boundary of the element
(boundary edges). 2) Judgment of Merge Possibilities It is judged whether or not the convex elements CLi and CHj can be merged with each other (step 1112). The judgment conditions are as follows. Condition 1: All boundary edges shared by the convex elements CLi and CHj are extracted. Whether or not they are shared can be determined by comparing the midpoints of the polygon sides forming the boundary ridge line. If there is no shared border ridge, it is determined that merging is not possible. Condition 2: With respect to the shared boundary ridge line, the unevenness relationship between the CLi polygon and the CHj polygon sharing the ridge line is examined. If there is at least one combination of polygons having a concave relationship, it is determined that merging is impossible. Condition 3: When conditions 1 and 2 are cleared, that is,
If the polygons have a convex relationship in all combinations of polygons sharing the boundary ridge, it is determined that merging is possible.

3) Merge Order Merge of convex elements is performed in the following order. 3-1) Convex element CL₁Is CH_j(j = 1,2, ... NPH) and Merge available
Determine whether or not. If CL₁Is CH_jAnd Merge is possible
Then, after that, CL₁, DC (PH) as follows
I do. CL₁∪CH_j→ CL₁  DC (PH) = $ CH₁, CH_Two, ... CH_j-1, CH_{j + 1}・
・ ・｝ 3-2) Execute the same procedure for CLi (i = 2,3, ... NPL)
You. 4) Configuration of merged convex element set DC (P) By the process of 3) above, merged convex element set DC (P) = Merge (DC (PL), D
C (PH)) is executed, and DC (P) = ｛CL₁, CL_Two, ... CLP_NPL, C
H_j', CH_jThe merged convex element set DC (P) given by "..." is output
(Step 1113). Where ｛CH_j', CH_j″ ...
・｝ Is for DC (PH) that does not merge with any CLI
It is a convex element.

(E) Determination of unevenness relationship between polygons FIG. 6 is an explanatory diagram of the unevenness relationship determination process between polygons.
As shown in FIG. 6 (a), two sharing one boundary ridge BEG
Suppose polygons A and B. The relative positional relationship between polygons is either distant from each other or in contact with each other via a ridge as shown in FIG. 6A, and the other relationship (for example, intersection at a portion other than the ridge) Etc.). In FIG. 6A, vectors b and c are perpendicular vectors dropped from the centers of gravity p and q of the polygons B and A to the boundary ridgeline x ₁ −x ₀ = a, respectively. Also, the unitized vectors a, b, and c are e ₀ , e ₁ ,
and e _2. n _A and n _B represent outward normal vectors of polygons A and _B , respectively (average of light reflection directions at respective grid points defining the polygon). At this time, b, c, e ₀ , e ₁ and e ₂ are given by the following equations.

B = px _0- (x ₁ -x ₀ ) · (px ₀ ) (x ₁ -x ₀ ) / | x ₁ -x ₀ | ² · is a vector dot product = px ₀ -e _0. ( px ₀ ) e ₀ c = q-x ₀ -e ₀・ (q-x ₀ ) e ₀ e ₀ = a / | a | e ₁ = b / | b | e ₂ = c / | c | In order to determine the unevenness relationship between the polygons A and B, the vector b is X ₀ as shown in FIG. Perform coordinate transformation to match the axis. The transformation matrix at this time is

(Equation 1) Given by

If one of the following two conditions is satisfied depending on the direction of the normal vector n _B , it can be said that the polygon A and the polygon B have a convex relationship. That is, 1) When (e ₀ × e ₁ ) · n _B > 0 [T · c] _Z <0 and when (e ₁ × e ₂ ) · n _A > 0, 2) ( When e ₀ × e ₁ ) · n _B ≦ 0 [T · c] _Z ≧ 0 and (e ₁ × e ₂ ) · n _A ≦ 0, the polygons A and B are convex. It can be said that there is a relationship. Actual C
When dealing with AD data, the judgment conditions are as follows, taking into account errors.

1) When (e ₀ × e ₁ ) · n _B > 0 When [T · c] _Z <ε and (e ₁ × e ₂ ) · n _A > −ε, 2 ) When (e ₀ × e ₁ ) · n _B ≦ 0 [T · c] _Z ≧ −ε and (e ₁ × e ₂ ) · n _A ≦ ε, polygon A and polygon B Are in a convex relationship. Here, ε is a very small amount determined depending on the object to be handled. Each element of the set DC (P) of the polygon subset obtained by the divide and conquer method is not necessarily convex. The unevenness determination condition shown in FIG. 6 is a local condition. However, when the initial polygon set is divided under the conditions shown in FIG. 6, very good convexity is exhibited in many cases.

(B) Second Embodiment When the convex decomposition is performed by the basic algorithm based on the divide-and-conquer method, the number of convex elements after the decomposition is not always the minimum. In the second embodiment, the number of convex elements is optimized (minimized as much as possible) by repeatedly using the basic algorithm of convex decomposition. The optimization method of the second embodiment is not a method of strictly minimizing the number of convex elements, but a method of reducing the number of elements as much as possible within a limited time. FIG. 7 is a flowchart of the process of the second embodiment (optimization method). An initial polygon set (polygon set of non-convex polyhedron) P is input from a three-dimensional CAD system or the like (step 1201), and a basic algorithm for convex decomposition based on the divide and conquer method is applied to the initial polygon set P (step 1202). . That is, the initial polygon set P is divided into first and second groups, and a polygon subset having a convex relationship with adjacent polygons in each group is obtained. Next, the polygon subsets of the first group and the polygon subset of the second group having a common boundary ridge are merged in a convex relationship to form a plurality of new polygon subsets DP1, DP2,.・ ・

Thereafter, the polygon subsets DP1, DP
A convex element set DC (P) having 2,... As elements is output (step 1203). The number of convex elements is NDC (P)
It is. Next, the convex decomposition basic algorithm based on the divide-and-conquer method is applied to the convex element set DC (P) again (step 1204). That is, a plurality of polygon subsets constituting the convex element set DC (P) are divided into first and second groups, and in each group, a subset of polygons having a convex relationship with adjacent polygons is obtained, and a common subset is obtained. A plurality of new polygon subsets DDP1, DDP2,... Are obtained by merging polygon subsets of the first group having boundary edges and polygon subsets of the second group in a convex relationship. Then, the polygon subsets DDP1, DDP
Convex element set DC (DC (P)) having 2,.
Is output (step 1205). The number of convex elements is ND
DC (P).

Next, the number of polygon subsets NDC (P) obtained previously and the number ND of polygon subsets obtained this time are calculated.
DC (P) is compared (step 1206), and if they match, a convex element set DC (DC (P)) is finally output (step 1207). And this convex element set DC
A convex polyhedron is generated using a polygon subset constituting (DC (P)). On the other hand, if NDDC (P) and NDDC (P) are not equal (for example, NDDC (P) <NDC ( P)), DC
(DC (P)) → DC (P) (Step 120
8) Thereafter, the processing from step 1204 is repeated.
That is, a plurality of newly obtained polygon subsets DC
(DC (P)) is repeatedly subjected to convex decomposition processing by the divide-and-conquer method. In the optimization method, the basic algorithm for convex decomposition is repeatedly applied to the output DC (P) until the number of convex elements no longer decreases.

(C) Third Embodiment In the method using the basic algorithm based on the divide-and-conquer method,
In the recognition of holes and the like, the number of divided convex elements may increase more than expected. In the third embodiment, in order to reduce the number of convex elements, convex decomposition processing is performed on an object such as a hole by regarding a Boolean algebra as negative, and the convex decomposition processing of the first embodiment is performed on other positive objects. Is applied. To regard a Boolean algebra as negative is to simply reverse the sign of the normal direction of each polygon (reverse the normal direction). Combining the basic algorithm based on the ordinary divide-and-conquer method and the negative object recognition method enables convex decomposition with a small number of convex elements.
FIG. 8 is an explanatory diagram of an object expression method by a Boolean set operation of an object including a shape such as a hole (negative object). HL is a hole, HL '
Is a hole part whose normal direction is reversed, and BDY is an object without a hole (an object without a hole). An object with a hole is represented by subtracting a hole portion whose normal direction is reversed from the object BDY without a hole.

FIG. 9 is a flowchart of the convex decomposition processing of the third embodiment.
FIG. 10 is an explanatory diagram of the result of the convex decomposition. 3D CAD
Initial polygon set by the system or the like enter the P (polygon set of non-convex polyhedron) (step 1301), then making the polygon set P _B was reversed all the normal direction of the initial polygon set P (step 1302). Thereafter, applying a convex decomposition basic algorithm for polygon set P _B (step 1303). That is, the polygon set P _B is divided into first and second groups, and a polygon subset having a convex relationship with adjacent polygons in each group is obtained. Next, a plurality of new polygon subsets for each convex element are obtained by merging polygon subsets of the first group and polygon subsets of the second group having a common boundary ridge in a convex relationship.

Thereafter, a convex element set DC (P _B ) (see FIG. 10) having the plurality of polygon subsets as elements is output, and for each convex element of the convex element set DC (P _B ),
A convex element composed of two or more polygons is extracted, and all the polygon sets constituting the convex element are represented by P ₂ (D
C (P _B )). That is, polygons constituting a negative object convex element such as a hole are collected and set as P ₂ (DC (P _B )) (step 1304). Next, a difference set between the initial polygon sets P and P ₂ (DC (P _B )) is obtained, and a polygon set PP ₂ (DC (P _B )) constituting the positive object is obtained (step 130).
5). When the polygon set (difference set) constituting the regular object is obtained, a basic algorithm for convex decomposition by the divide-and-conquer method is applied to the difference set PP ₂ (DC (P _B )) (step 130)
6). That is, the difference set PP ₂ (DC (P _B )) is divided into the first and second 2
It divides into two groups, and obtains a polygon subset having a convex relationship with adjacent polygons in each group. Next, a plurality of new polygon subsets for each convex element are obtained by merging polygon subsets of the first group and polygon subsets of the second group having a common boundary ridge in a convex relationship. Thereafter, a convex element set DC (PP ₂ (DC (P _B ))) having the plurality of polygon subsets as elements is output (step 1307, FIG. 10), and a positive object is recognized. Finally, DC (PP ₂ (DC (P _B ))) is a convex element of a positive object, DC
(P _B ) is output as a convex element of a negative object (Step 1)
308). Thereafter, a convex polyhedron is generated using the polygon subset of each convex element.

(D) Fourth Embodiment The number of convex elements is reduced by applying the optimization method to the third embodiment, similarly to the case where the number of convex elements is reduced by applying the optimization method to the first embodiment. be able to. FIG. 11 is a flowchart of the convex decomposition processing in such a case, and is different from the third embodiment in that an optimization method is applied instead of the basic convex decomposition algorithm in steps 1303 'and 1306'.

(E) Fifth Embodiment of the Present Invention (a) Consideration In the above embodiment, the polygon subset C of the first group is used.
Merge of Li and polygon subset CHj of the second group
The possibility is determined as follows. That is, irrespective of whether the polygon subset CLi and the polygon subset CHj have a common edge or not, all of the polygon edges forming the boundary edge of CLi and all the polygon edges forming the boundary edge of CHj A common boundary ridge is determined based on whether or not the points match.

However, in the merging possibility determination processing, it is not necessary to check whether or not the midpoints match in all combinations of polygon subsets and in all-round combinations of polygon sides forming the boundary ridge line. Therefore, it takes a considerable amount of time to determine the possibility of Merge,
This limits the speed of convex decomposition. By the way, when the boundary ridge line of the convex element CLi and the boundary ridge line of the convex element CHj have a common boundary ridge portion, the convex object composed of the boundary ridge line of the convex element CLi and the convex object composed of the boundary ridge line of the convex element CHj And interfere. Therefore, before executing a process for obtaining a common boundary ridge line between the convex elements CLi and CLj, the boundary between the convex object and the convex element CHj formed by the boundary ridge line of the convex element CLi is calculated by an interference check method of O (N). It is checked whether or not there is interference between the ridge and the convex object. When no interference occurs, the subsequent merge processing is skipped, and only when interference occurs, the subsequent merge processing is continued. In this way, the time required for the Merge processing can be greatly reduced, and the convex decomposition processing can be performed at high speed.

(B) Outline of Interference Check Pre-Processing FIG. 12 is another schematic processing flow of the interference checking pre-processing of the fifth embodiment, and the same parts as those of the first embodiment of FIG. doing. The difference from the first embodiment is that in step 1003 ', a basic algorithm for convexity decomposition (basic algorithm for high-speed convex decomposition) based on a divide-and-conquer method incorporating an interference check is applied in place of the basic algorithm for convex decomposition by divide-and-conquer method. It is a point.

FIG. 13 is a flowchart of the processing of the basic algorithm for high-speed convex decomposition. An initial polygon set (polygon set of a non-convex polyhedron) P is input (step 1101), and then the initial polygon set P is subjected to convex decomposition processing by a high-speed convex decomposition algorithm (step 1102 '). That is, the initial polygon set P is divided into first and second groups, and a polygon subset having a convex relationship with adjacent polygons in each group is obtained. Next, the polygon subset of the first group and the polygon subset of the second group having a common boundary ridge are merged (merged) in a convex relationship, and a plurality of new polygon subsets DP1 for each convex element are merged. DP2,... Thereafter, the polygon subsets DP1, DP2,... Are output (step 1103). Note that each polygon subset DP
A convex polyhedron is generated based on 1, DP2,.
The most important place where the problem dependency exists in the divide-and-conquer method is the "merging" process, that is, how to construct the function Merge.

(C) Merge process in the divide-and-conquer method In order for the convex elements CLi and CHj to be mergeable, C
Li and CHj have a common boundary edge. That is, it is a necessary condition that the convex elements CLi and CHj interfere with each other through the boundary ridge line. Therefore, the interference check algorithm is applied between the convex elements CLi and CHj, and if there is no interference, the subsequent merge processing can be skipped for CLi and CHj. FIG. 14 is a flowchart of the Merge process in the divide-and-conquer method. 1) Prepare convex element set DC (PL), DC (PH)
(Steps 1111a and 1111b). DC (PL) = {CL1, CL2, ··· CLi, ···} i = 1,2, ··· NDC (PL) CLi {polygons = {p CL11, p CL12, p CL13, ··· p _{NCLP1} boundary edges = {b CL11} , b CL12, b CL13, ··· b NCLB1}} DC (PH) = {CH1, CH2, ·· CHi, ···} i = 1,2, ··· NDC (PH) CLi ｛polygons = ｛p _CH11 , p _CH12 , p _CH13 , ... p _NCHP1 ｝ boundary edges = {b _CH11 , b _CH12 , b _CH13 , ... b b _NCHB1 ｝｝ convex element set DC (PL) , DC (PH) are composed of polygon subsets (polygons) and a set of boundary edges (boundary edges) forming the boundaries of the elements.

2) Judgment of Merge Possibility It is judged whether or not the convex elements CLi and CHj can be merged with each other (step 1112 '). The judgment conditions are as follows. Condition 1: Boundary edges Bedge _CLi , Be of convex elements CLi, CHj
_Perform interference check between dge _CHj . Merg without interference
e Judge as impossible. Condition 2: convex elements CLi, CH possibly interfering
For j, all boundary edges shared between CLi and CHj are extracted. Whether or not they are shared can be determined by comparing the midpoints of the polygon sides forming the boundary ridge line. If there is no shared border ridge, it is determined that merging is not possible. Condition 3: With respect to the shared boundary ridge line, the unevenness relationship between the CLi polygon and the CHj polygon sharing the ridge line is examined. If there is at least one combination of polygons having a concave relationship, it is determined that merging is impossible. Condition 3: Me when Condition 1, Condition 2, and Condition 3 are cleared
Judge that rege is possible.

3) Merge Order Merge of convex elements is performed in the following order. 3-1) Convex element CL₁Is CH_j(j = 1,2, ... NPH) and Merge available
Determine whether or not. If CL₁Is CH_jAnd Merge is possible
Then, after that, CL₁, DC (PH) as follows
I do. CL₁∪CH_j→ CL₁  DC (PH) = $ CH₁, CH_Two, ... CH_j-1, CH_{j + 1}・
・ ・｝ 3-2) Execute the same procedure for CLi (i = 2,3, ... NPL)
You. 4) Configuration of merged convex element set DC (P) By the process of 3) above, merged convex element set DC (P) = Merge (DC (PL), D
C (PH)) is executed, and DC (P) = ｛CL₁, CL_Two, ... CLP_NPL, C
H_j', CH_jThe merged convex element set DC (P) given by "..." is output
(Step 1113 '). Where ｛CH_j', CH_j″ ・
・ ・｝ Is the DC (PH) that does not merge with any CLI
It is a convex element.

(D) Interference Check Algorithm Among the interference check algorithms between convex objects, Bobrow
Method, Lin / Canny method, and Gilbert method can be used as interference check methods for the existing computational load O (N). FIG. 15 is a schematic processing flow of the interference check algorithm. Convex element CLi,
An interference check algorithm is applied between convex objects constituted by the boundary edges Bedge _CLi and Bedge _CHj of CHj (step 1401). By applying the interference check algorithm, the distance between the closest points of the boundary edges Bedge _CLi and Bedge _CHj dist (Bed
ge _CLi , Bedge _CHj ) and output it (step 140).
2). Once the distance between the closest points is obtained, the distance dist (Bedge
_CLi, and compares the Bedge _CHj) and ε, dist (Bedge _CLi, B
edge _CHj ) ≦ ε, it is determined that interference occurs, and dist (Bedge
_{If CLi} , Bedge _CHj )> ε, it is determined that there is no interference.
Here, ε is a user-defined minute constant that determines the accuracy of the interference check determination.

(F) Interference Check Method (Gilbert Method) (f-1) Object Representation Method and Distance Between Objects Consider a convex polyhedron X in a three-dimensional space. At this time, an arbitrary point x in X is a lattice point (vertex) xi∈ located at the boundary of X.
It can be expressed as follows using X. x = Σλi · xi (i = 1 to m): xi∈X, λi ≧ 0 λ ₁ + λ ₂ +... + λm = 1 (1) The above equation is expressed as a set of lattice points {xi: i = 1,2, .. May be defined as a convex polyhedron spanned by m｝. {xi} is called the base of the convex polyhedron X. Now, two convex polyhedrons K ₁ and K ₂
think of. At this time, the closest approach distance between the two objects is defined as follows.

D (K ₁ , K ₂ ) = min ｛| xy−: x∈K ₁ , y∈K ₂ ) (2) where x and y are position vectors, and | xy− = {(X ₁ −y ₁ ) ² + (x ₂ −y ₂ ) ² + (x ₃ −y ₃ )} ² . Therefore, the problem of finding the point of closest approach between two convex polyhedrons is to find x, y that satisfies equation (2) by the following equation. x = {λi · xi (i = _{1 to} m ₁ ): xi∈K ₁ , λi ≧ 0 λ ₁ + λ ₂ +... + λm ₁ = 1 y = {μi · yi (i = 1 to m ₂ ): yi} K ₂ , μi ≧ 0 μ ₁ + μ ₂ +... + Μm ₂ = 1 (3) When simply considered, in equation (3), since both λ and μ are variables, the calculation load is O (M ₁ · M ₂ ). Equation (2) can be rewritten as follows.

The union and difference sets of arbitrary objects K ₁ and K ₂ are represented by K
_{1 ± K 2 = {x ±} y: x∈K 1, y∈K 2} when defined,
Equation (2) is equivalent to the following equation. d ₁₂ = min ｛| z |: z∈K｝, K = K ₁ −K ₂ (4) The union of the objects K ₁ and K ₂ is the vector addition of arbitrary position vectors x and y of each object. And the difference set of the objects X ₁ and X ₂ is a set of position vectors z obtained by vector subtraction of arbitrary position vectors x and y of each object. Object. Equation (4) shows that the search for the closest approach point
This is equivalent to the problem of finding the closest point to the polyhedron K from. When both the polyhedrons K ₁ and K ₂ are convex polyhedrons, the polyhedron K is also a convex polyhedron, and a set Z of lattice points constituting the convex polyhedron K is given below.

Z = ｛zi = xj−yk: xj∈K₁, Yk∈K_Two, I = 1,2, ... m₁m_Two  j = 1,2, ... m₁  k = 1,2, ... m_Two｝ (5) Summarizing the above, the following conclusions are drawn. Sand
Chi, "Two convex polyhedrons K₁, K_TwoFor finding the closest point between
The title is a convex polyhedron K (= K₁-K_TwoThe best to
Equivalent to the problem of finding the approach point. Where K is m₁m_TwoPieces (m₁:
K₁Grid points of m _Two: K_TwoLattice points ｛zi =
xj-yk} is a convex polyhedron. "

(F-2) Outline of Gilbert's Method From the conclusion in (f-1), the problem of finding the point of closest approach between the _two convex polyhedrons K ₁ and K _{2 is} the closest approach from one point O to the convex polyhedron K. It comes down to the problem of finding points. The Gilbert method uses this fact and a function called a support function, described below. Support function hx for convex polyhedron
(η): R ³ → R is defined as follows. hx (η) = max {xi · η: i = 1 to m} (6) where {xi} is a set of lattice points serving as a base of the convex polyhedron X, and denotes a vector inner product. , And R
³ → R means conversion from three dimensions to one dimension. Therefore, the port function hx (η) in the equation (6) means that, when the vector η is determined as shown in FIG. 16, the lattice point of the convex polyhedron X farthest from the origin in the direction is determined. ing. Now, assuming that a vector (position vector) from the coordinate origin O to this grid point is sx (η), the equation (6) is as follows.

Hx (η) = sx (η) · η (7) The calculation load of the closest approach point search by the Gilbert method is O (M ₁ + M ₂ ).
Becomes The reason is based on the fact that the following rule is satisfied for the support function hk (η) and the position vector sk (η) of the difference set K of the convex polyhedrons K ₁ and K ₂ . hk (η) = hk ₁ (η) + hk ₂ (−η), sk (η) = sk ₁ (η) −sk ₂ (−η) (8) The above equation is obtained from m ₁ m ₂ grid points. Convex polyhedron K = K ₁ −K ₂
Mean that the support function for is composed of the sum of the support functions for the convex polyhedrons K ₁ and K ₂ . Therefore, as is clear from the definition of the equation (6), the calculation load for obtaining hx (η) is O (M ₁ + M ₂ ). The essence of the search for the closest point by the Gilbert method is that the support function hx (η) is repeatedly used to gradually approach the closest point. That is, the Gilbert method includes the following four processes.

(F-3) Algorithm for searching for the closest point by the Gilbert method 1) Initialization For the convex polyhedrons K ₁ and K ₂ , let K be the difference convex polyhedron K ₁ −K ₂ . Take arbitrary points in the convex polyhedron K and denote them as y ₁ , y ₂
... Yp と す る K. Incidentally, y ₁ , y ₂ ... Yp need not necessarily be the base lattice points of the convex polyhedron K. p is generally 1 ≦ p ≦ 4. At this time, a set of initial lattice points V _k
(= V ₀ ) is set to V _k = {y ₁ , y ₂ ... Yp}, k = 0.

2) Search for the closest point to the basic polyhedron With respect to a set Vk of lattice points consisting of the number of elements p (four or less), ν _k = ν (co V _k ) (9) is calculated. Here, co V _k is a convex polyhedron based on the lattice point set V _k , and ν (X) is a convex polyhedron X from the coordinate origin O.
Represents a vector (position vector) of the point of closest approach to.

3) Determination of closest approach point A function g _x (x) for R ³ → R is defined as follows. g _x (x) = | x | ² + h _x (−x) In the above equation, the first term on the right side means the square of the distance to a given point on the convex polyhedron K, where x is the position vector. The second term on the right side means the inner product of the lattice point position vector closest to the origin in the vector x direction and the vector -x. In other words, h _x (−x) is the minimum value of the inner product of the position vector of the grid point and x. This g
x (x) is a determination function of the closest approach point, and x is K from the origin O
If it is the closest point to
_x (x) = 0. It can be proved that gx (x) is a function for determining the closest approach point, but is omitted. Details are described above,
`` IEEE JOUNAL OF ROBOTICS AND AUTOMATION, VOL.4, N
O.2, APRIL 1988, pp. 193-203 `` A Fast Procedure for C
omputing the Distance Between Complex Objects in T
hree-Dimensional Space ". From the above,
If g _k (v _k ) = 0 (10) with respect to v _k obtained by equation (9), v (K) = v _k and the closest approach point search process is terminated.

4) Increment of k If equation (10) does not hold, k is incremented. That is, V _{(k + 1) is set} to V _{(k + 1)} = V _k ′ ∪ ｛s _k (−ν _k )} (11). Here, V _k ′ is V _k ′ ⊆V _k and ν _k
It is the minimum subset of V _k that becomes ∈co V _k ′. (11) is a subset of V _k V _k 'and ([nu _k a comprises) closest grid point from the origin to the point of closest approach vector [nu _k direction in V _k s _k
A set including (−ν _k ) is meant. From the above, if equation (10) does not hold, k is incremented by equation (11).
Returning to 2), the subsequent processing is repeated until Expression (10) is satisfied.

(F-4) Application of closest point search algorithm by Gilbert method In order to deepen the understanding of the closest point search algorithm by Gilbert method, the closest point search will be described with reference to FIG. In FIG. 17, the initial value V ₀ = {z ₁ , z ₂ , z ₃ }
And then, the [nu ₀ when obtaining the point of closest approach vector in V _0. At this time, since the expression (10) is not satisfied, k is incremented. V ₁ = V _{0 is' ∪ {s k (-ν 0} )} = V 0 '∪ {z 4}, _{also, V 0' = {z 2} , z 3} from the V ₁ = {z
_2, z _3, a z _4}. When the closest point vector at V ₁ is obtained, it becomes ν ₁ . At this time, since the expression (10) is not satisfied, k is incremented.

V ₂ = V ₁ ′ {s _k (−ν ₁ )} = V ₁ ′ {z ₅ }, and V ₁ ′ = {z ₃ , z ₄ }, so that V ₂ = ｛Z
₃ , z ₄ , z ₅ }. When the closest point vector at V ₁ is obtained, it becomes ν ₂ , and this ν ₂ satisfies the expression (10),
ν ₂ is the closest approach point vector, and ν ₂ = ν (K) Ｋco {z ₄ , z ₅ }. As a result, the closest approach distance d is d = | ν ₂ |. Try the same with different initial values. In FIG. 30, when the initial value V ₀ = {z ₂ } and the closest point vector at V ₀ is obtained, ν ₀ ′ (= z ₂ ). At this time, (1
Since equation (0) is not satisfied, k is incremented. V ₁ = V ₀ ′ ∪ ｛s _k (−ν ₀ ′)} = V ₀ ′ ∪ ｛z ₅ 、 and V ₀ ′ = ｛z ₂か ら, V ₁ = ｛z ₂ , z
₅ ｝.

When the closest approach point vector at V ₁ is obtained, it becomes ν ₁ '. At this time, since the expression (10) is not satisfied, k is incremented. V ₂ = V ₁ ′ ∪ ｛s _k (−ν ₁ ′)} = V ₁ ′ ∪ ｛z ₄ 、 and V ₁ ′ = {z ₂ , z ₅か ら, so that V ₂ = ｛z
_2, z _4, the z _5}. Determining points of closest approach vector in V ₂ When ν ₂ '(= ν _2), and this [nu _2' (10)
The equation is satisfied, and ν ₂ becomes the closest point vector, and ν ₂ ′ = ν ₂ = ν (K) ∈co ｛z ₄ , z ₅ ｝. As a result, the closest approach distance d becomes d = | ν ₂ |, and the same result as when the initial value V _{0 is set} to V ₀ = {z ₁ , z ₂ , z ₃ } is obtained.

The initial lattice point (initial value) of the Gilbert method
Although V ₀ is generally arbitrary, it is efficient to start from a lattice point in the gravity center difference direction of each convex polyhedron as shown below. v ₀ = {s _k (−z _c1 + z _c2 )} (12) where z _c1 and z _c2 are respectively z _c1 = Σ (xi / M ₁ ) (i = _{1 to} M ₁ ) xi: convex polyhedron Base lattice point of K ₁ z _c2 = Σ (yi / M ₂ ) (i = 1 to M ₂ ) yi: Base lattice point of convex polyhedron K ₂ . When finding the point of closest approach by the Gilbert method, the following inequality holds (see FIG. 18). r _k = −h _k (−ν _k ) / | ν _k | ≦ | ν (K) | ≦ | ν _k | (13) Therefore, for a certain k, if r _k > 0, the interference between the biconvex objects There is no.

(G) Merge Possibility Judgment Processing Based on Gibert Method FIG. 19 is a flowchart of the Merge possibility judgment processing based on the Gilbert method. Boundary ridges Bedge _CLi , Be of convex elements CLi, CHj
by applying the Gilbert method between each composed convex object with dge _CHj, it computes the r _k of (13) (step 141
1). Next, r _k> 0 it is determined whether or not (step 141
2) If r _k > 0, there is no interference, so it is determined that Merge is not possible (step 1413). However, if r _k ≦ 0, it is determined that Merge interference exists because of interference, and Merge possibility / impossibility is determined from the above Merge possibility conditions 2 to 4 (step 1414).

(H) Merge Possibility Determination Processing Based on Simplified Gibert Method Merge possibility determination processing based on the Gibert method is further simplified. The point of simplification is to set an arbitrary vertex from the vertex set Bedge _CLi and Bedge _CHj on the boundary edge as the initial lattice point V ₀ of the Gilbert method.
Select the Bedge _CLi0, Bedge _CHji0, constitute V ₀ = Bedge _CLi0 -Bedge _CHji0 (14). Then, using this V ₀ , r = −h _k (−V ₀ ) = − h _k1 (−V ₀ ) −h _k2 (V ₀ ) (15) is calculated. If r> 0, Bedge _CLi , Bedge _CHj
There is no interference between them, and it is determined that there is no possibility of merging the convex elements CLi and CHj.

FIG. 20 shows Mer based on the simplified Gilbert method.
It is a ge possibility determination processing flow. Convex elements CLi, CHj
Applying the simplified Gilbert method between convex objects composed of the boundary edges Bedge _CLi and Bedge _CHj of
Is calculated (step 1411 '). Next, it is determined whether r> 0 (step 1412 ′). If r> 0, there is no interference, so it is determined that Merge is impossible (step 141).
3 '). However, when r ≦ 0, interference occurs.
It is determined that there is Merge interference, and Merge is possible / impossible from the above Merge possibility conditions 2 to 4 (step 141).
4 ').

(F) Modifications (a) Modification 1 The number of convex elements can be reduced by performing optimization processing on the convex decomposition method of the fifth embodiment described above. FIG. 21 shows a processing flow in this case. In FIG. 21, the difference from the processing of the second embodiment (see FIG. 7) is that step 120
In 2 'and 1204', a high-speed convex decomposition algorithm incorporating an interference check is used instead of the basic convex decomposition algorithm. (b) Modification 2 The high-speed convex decomposition algorithm incorporating the interference check can be applied to the convex decomposition processing in the presence of a negative object, and the processing flow in this case is shown in FIG. In FIG. 22, the point different from the third embodiment is that step 1303 ′,
In 1306 ', a fast convex decomposition algorithm incorporating an interference check is used instead of the basic convex decomposition algorithm. (c) Modification 3 Modification 2 may be further optimized to reduce the number of convex elements. As described above, the present invention has been described with reference to the embodiments. However, the present invention can be variously modified in accordance with the gist of the present invention described in the claims, and the present invention does not exclude these.

[0052]

As described above, according to the present invention, a polygon subset for each convex element can be obtained at high speed by convex decomposition processing by the divide-and-conquer method. Therefore, a non-convex polyhedron can be quickly formed using the polygon subset. A convex polyhedron can be generated, and an interference check method such as the Gilbert method having real-time property can be applied to interference check of a non-convex polyhedron when checking interference between convex polyhedrons. According to the present invention,
Since a plurality of polygon subsets obtained by the divide-and-conquer method are repeatedly applied to the plurality of polygon subsets obtained by the divide-and-conquer method, it can be locally divided into the minimum number of convex polyhedrons.

Further, according to the present invention, when the non-convex polyhedron has a negative shape (negative object) such as a hole, the sign of the normal vector of each convex polygon (polygon) constituting the non-convex polyhedron Is inverted to assume an inverted shape model, and a polygonal subset of the negative object is obtained by applying the divide-and-conquer method to the inverted shape model. Thereafter, the negative object is calculated from the initial polygon set constituting the non-convex polyhedron. The polygon subset is removed, and a polygon subset of the regular object is obtained by applying the divide and conquer method to the non-inverted shape polygon set obtained by the removal. Then, since the convex polyhedron is generated from each of the positive and negative polygon subsets, even when the non-convex polyhedron has a negative object such as a hole, the non-convex polyhedron can be divided into a convex polyhedron including the negative object.

Further, according to the present invention, the merging possibility in the divide-and-conquer method is checked by checking whether or not a convex object constituted by the boundary edges of each polygon subset interferes. Since it is determined that there is no merging possibility, the subsequent merging possibility processing is skipped, and in the case of interference, it is determined that a common boundary edge exists, and the subsequent merging possibility processing is continued. The time required for processing the possibility can be reduced, and a polygon subset for each convex element can be obtained at high speed.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating the principle of the present invention.

FIG. 2 is a system configuration diagram of the present invention.

FIG. 3 is a schematic processing flow of an interference check pre-processing.

FIG. 4 is a processing flow of a convex decomposition basic algorithm.

FIG. 5 is a flow chart of the Merge process.

FIG. 6 is an explanatory diagram for determining the unevenness relationship between polygons.

FIG. 7 is a processing flow according to a second embodiment of the present invention.

FIG. 8 is an explanatory diagram of an object representation by a Boolean set operation.

FIG. 9 is a processing flow of a third embodiment of the present invention.

FIG. 10 is an explanatory diagram of a result of convex decomposition when there is a negative object.

FIG. 11 is a processing flow according to a fourth embodiment of the present invention.

FIG. 12 is another schematic processing flow of the interference check pre-processing of the present invention.

FIG. 13 is a flowchart of a fast convex decomposition basic algorithm.

FIG. 14 is a flow chart of the Merge process.

FIG. 15 is a schematic processing flow of an interference check algorithm.

FIG. 16 is an explanatory diagram of a support function.

FIG. 17 is an explanatory diagram of a search for a point of closest approach by the Gilbert method.

FIG. 18 is an explanatory diagram of the principle of interference check by the Gilbert method.

FIG. 19 is a flowchart of Merge possibility determination based on the Gilbert method.

FIG. 20 is a flowchart of Merge possibility determination based on the simplified Gilbert method.

FIG. 21 is a processing flow of a first modification of the present invention.

FIG. 22 is a processing flow of a second modified example of the present invention.

[Explanation of symbols]

1. Initial polygon set constituting non-convex polyhedron 2. Dividing means 3a, 3b Polygon sets of first and second groups 4a, 4b ... Means for obtaining polygon subsets having convex relations 5. Merging Means 6 ··· A plurality of polygon subsets in a convex relationship obtained by merging

──────────────────────────────────────────────────続 き Continuation of the front page (56) References JP-A-64-26981 (JP, A) JP-A-62-212783 (JP, A) JP-A-63-19075 (JP, A) JP-A-63-19075 178372 (JP, A) Information Processing Society of Japan, Graphics and CAD Symposium (1992), pp. 95-104, Atsuyoshi Sugihara, "Phase First Method, A Technique for Numerically Stabilizing Geometric Algorithms" (58) Survey Field (Int.Cl. ⁶ , DB name) G06F 17/50 G06T 17/00 JICST file (JOIS)

Claims (4)

(57) [Claims] A non-convex polyhedron is divided into convex polyhedrons.
Interference check for non-convex polyhedron interference check
In the convex polyhedron generation device in the check system, a large number of convex polygons (polygons) covering the surface of the non-convex polyhedron are generated .
Create a polygon data file containing shape data
The polygon data created by the polygon data creation section and the polygon data creation section
Instructs the memory for storing files and the start of the division process to divide a non-convex polyhedron into a convex polyhedron
The operation unit that executes the above-mentioned polygon data file stored in the memory.
Multiple polygons covering the surface of the non-convex polyhedron
Divide into 1 and 2 groups, adjacent in each group
Find a subset of polygons whose relationship with polygons is convex
Polygon subset creation processing unit, a first group of polygon subsets having a common boundary edge
And the polygon subset of the second group have a convex relationship
Merge things to find multiple new polygon subsets,
Convex which generates convex polyhedron using these polygon subsets
An interference check system comprising a polyhedron generation processing unit and an output unit for outputting a processing result.
Convex polyhedron making device. 2. The convex polyhedron generation processing unit determines whether or not two polygon subsets have a convex relationship by determining all combinations of polygons sharing the boundary ridge line, and in all combinations, the relationship between polygons is convex. , It is determined that the polygon subset of the first group and the polygon subset of the second group are in a convex relationship, and if even one set is in a concave relationship, it is determined that there is no convex relationship. 2. A convex polyhedron in the interference check system according to claim 1.
Equipment . 3. The convex polyhedron generation processing unit checks whether a convex object composed of a boundary ridge line of a polygon subset of a first group and a convex object composed of a polygon subset of a second group interfere with each other. If there is no interference, it is determined that there is no common boundary ridge. If there is interference, it is determined that there is a common boundary ridge. 3. The method according to claim 2, wherein whether or not there is a relationship is determined.
The convex polyhedron creation device in the interference check system described above. 4. The convex polyhedron generation processing unit divides the plurality of finally obtained polygon subsets into first and second groups, and in each group, a polygon having a convex relation with an adjacent polygon is formed. A subset is obtained, and a polygon subset of the first group and a polygon subset of the second group having a common boundary ridge are merged to obtain a plurality of new polygon subsets by combining the polygon subsets. If the number of polygon subsets obtained is not equal to the number of polygon subsets obtained this time, the above processing is further repeated for a plurality of newly obtained polygon subsets. The interference check according to claim 1, wherein a subset is output.
Convex polyhedron creation device in the system .