JP2002312409A - Closest point search device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To realize the high-speed continuous search between articles, while restricting a computing load. SOLUTION: In the case of continuously searching the closest point between projecting polygonal bodies to check the interference with each other, vertex coordinates of all polygons covering the projecting polygonal body are input, and stored in a polygon data memory unit 22a. A close point linear list forming unit 24 forms a close point linear list provided with the data structure formed by linking the vertex of each polygon in a first direction (next direction) and linking a vertex group connected to each vertex through a polygon side with the vertex in a second direction (branch direction) before carrying out the closest point search processing. Thereafter, a closest point search processing unit 26 finds the vertex close to the closest point on the basis of the close point linear list, and searches the closest point in the following time among the vertexes to check the interference.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to collision avoidance and path planning in the operation of robots and self-propelled vehicles (path planning).
The present invention relates to an apparatus for searching for the closest point which can be applied to a computer. In particular, it is possible to determine whether a plurality of object shape models (CG models) built on a computer are separated from each other, in contact with each other, or interfere with each other. In addition, the present invention relates to a closest approach point search device capable of calculating a closest approach point, a contact point, and a distance between objects in real time. The present invention provides a CAD system for machine design, path generation for mobile robots such as manipulators and self-propelled vehicles, animation creation in multimedia,
It can be applied to various fields using computer graphics such as game software.

[0002]

2. Description of the Related Art Generally, a robot is operated by remote control by an operator or program operation based on data created on a computer. When remotely controlling the robot, the operator must operate the robot while avoiding unexpected collision or interference with other objects surrounding the robot. When a robot is operated by a program, it is necessary to perform path planning on a computer in advance so as not to cause collision or interference with an obstacle. On the other hand, when operating a self-propelled vehicle, the self-propelled vehicle fetches environmental map data in the direction in which the vehicle is going to travel through a sensor and autonomously runs while avoiding obstacles, or uses map information stored in advance on a computer. Program running according to the path created based on the. In these cases, it is necessary to perform sequential collision avoidance and path planning that does not cause interference as in the case of the robot.

[0003] If the closest point and the distance between objects can be measured, a robot or a self-propelled vehicle can be moved while avoiding obstacles. You can run. For this reason, there is a demand for a method of searching for a point of closest approach between objects in sequential collision avoidance of robots and self-propelled vehicles and in advance path planning. That is, when there are a plurality of objects, it is determined whether they are separated from each other, in contact with each other, or interferes with each other, and the closest point between the objects (in the case of contact or interference, , A contact point or an interference point) and a closest approach point searching method for efficiently calculating a distance.

The basic approach to the closest point search problem is a method in which shape, position, and orientation data of a target object is loaded on a computer and solved by elementary geometric calculation. Normally, graphic simulators used in the CAD field use planar convex polygons (convex polygons).
Are attached to represent one object. Therefore,
The simplest method for checking the interference state between two objects is to search for the closest approach point between the convex polygons constituting each object for all the combinations of the convex polygons. Specifically, for each convex polygon constituting two objects arbitrarily arranged in space, the closest point is searched for each grid point (vertex), side, and surface, and the closest approach distance is determined. It is to calculate. Of course, when the closest approach distance is zero, it can be said that the two objects are in an interference state. In this method, when the number of grid points representing two objects is M1 and M2, a calculation load of O (M1 · M2) is involved. O () is a function indicating the order of the calculation load.

The development of an algorithm for reducing the computational load of O (M1 · M2) has been studied mainly in the field of computational geometry, and the asymptotic property of O (MlogM) (M = M1 + M2) ( An algorithm with M1 and M2 being very large) has been developed. Although this type of algorithm is theoretically correct, both focus on asymptotic properties,
Practical discussions on how much the computational load is reduced when M1 and M2 are of a practical size are lacking, and cannot be said to be a truly practical algorithm. On the other hand, historically, a method using a Voronoi diagram that connects the perpendicular bisectors between the grid points to illustrate the proximity relationship between the grid points,
It is also known to search for the closest approach point by an oct-tree method in which a three-dimensional space is divided into eight equal parts one after another for each quadrant, and the occupied area of the object is made into a database. Each of these methods is effective when the target is statically constant,
It is not suitable when the target changes dynamically one after another due to disassembly or assembly.

Now, in order to improve the practicality of the closest point search algorithm, it is necessary to cover the following requirements 1) to 5). 1) Extension to non-convex polyhedron In the closest point search algorithm that has been conventionally developed for computational geometry, etc., the object to be handled is limited to a convex polyhedron (see FIG. 69 (a)). However, in practice, many interference problems with the non-convex polyhedron occur as shown in FIG. 69 (b). Therefore, it is necessary to extend the closest point search algorithm to a non-convex polyhedron. The convex polyhedron is a polyhedron in which a line connecting any two points inside the polyhedron is included in the polyhedron.

2) Extension to non-single connected polyhedron When assembling a truss or plumbing, it is necessary to consider the interference with a perforated object. FIG. 69 (c) shows the assembly of the truss, where TR is the truss and RBH.
Is a robot hand. 3) Extension to an object with a general free-form surface An object with a general free-form surface is represented by a combination of multiple polygons on a graphic simulator. FIG. 69 (d) shows the assembly of an antenna having a free-form surface, where AT is an antenna and RBH is a robot hand. In order to deal with the problem of interference with an object having a general free-form surface, it is necessary to increase the number of polygons to increase the approximation accuracy, or to treat the curved surface analytically using a spline surface or the like.

[0010] 4) Responsiveness to environmental fluctuations The object handled in the interference problem is not always stationary, and generally the environment dynamically fluctuates through operations such as disassembly, transportation, and assembly. Combining convex polyhedrons to assemble a non-convex structure often occurs. When each ring of the arm is represented by a convex polyhedron, the arm itself can be regarded as an aggregate of dynamically moving convex polyhedrons (generally a non-convex object). At this time, when trying to grasp the target object OBJ with the robot hand RBH at the tip of the arm AM as shown in FIG. 70 (a), not only the interference between the hand and the target object but also the arm elbow and the other object OBS Must be considered.
Practical algorithms must be able to respond flexibly and quickly to such dynamic environmental changes.

5) Response to Shape Change When the target object has flexibility, the shape of the object itself dynamically changes (see FIG. 70 (b)). This can be regarded as a kind of environmental change in 4), but handling is more difficult with shape change. For this reason, Professor Gilbert of Michigan University has proposed an extremely practical method (called the Gilbert method) for the search for the point of closest approach between convex polyhedrons. This Gilbe
According to the rt method, the computational load of the algorithm is O.sub.0 for most convex polyhedral combinations with very pathological exceptions.
(M1 + M2). The Gilbert method is extended to a non-convex polyhedron by considering the non-convex polyhedron as a set of a plurality of convex polygons. Hereinafter, the Gilbert method will be described in detail.

[0010] Finding the closest point between convex polyhedrons using the Gilbert method
Search algorithm (a) 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 λ1 + λ2 +... + λm = 1 (1) Using the above equation, a set of lattice points [xi: i = 1, 2,.凸 may be defined as a convex polyhedron. [xi｝ is called the base of the convex polyhedron X. Now, two convex polyhedrons K1, K
Consider 2. At this time, the closest approach distance between the two objects is defined as follows.

D (K1, K2) = min ｛| xy−: x∈K1, y∈K2) (2) where x and y are position vectors, and | xy− =
｛(X1-y1) 2+ (x2-y2) 2+ (x3-y
3) $ 2. Therefore, the problem of finding the point of closest approach between two convex polyhedrons is to find x and y that satisfy equation (2) by the following equations. x = Σλi · xi (i = 1 to m1): xi∈K1, λi ≧ 0 λ1 + λ2 +... + λm1 = 1 y = Σμi · yi (i = 1 to m2): yi∈K2, μi ≧ 0 μ1 + μ2 +. + Μm2 = 1 (3) In simple terms, in equation (3), since both λ and μ are variables, the calculation load is O (M1 · M2). Equation (2) can be rewritten as follows.

When the union and difference sets of arbitrary objects K1 and K2 are defined by K1 ± K2 = {x ± y: x {K1, y} K2}, equation (2) is equivalent to the following equation. d12 = min ｛| z |: z∈K｝, K = K1−K2 (4) The union of the objects K1 and K2 is a position vector obtained by vector addition of arbitrary position vectors x and y of each object. The difference set between the objects X1 and X2 is an object formed from a set of position vectors z obtained by vector subtraction of arbitrary position vectors x and y of each object. Equation (4) indicates that the problem of searching for the closest point is equivalent to the problem of finding the closest point to the polyhedron K from the coordinate origin O. When both the polyhedrons K1 and K2 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∈K1, yk∈K2, i = 1, 2,... M1m2 j = 1, 2,... M1 k = 1, 2,. ｝ (5) Summarizing the above, the following conclusions are drawn. That is, "the problem of finding the closest point between the two convex polyhedrons K1 and K2 is equivalent to the problem of finding the closest point from the coordinate origin O to the convex polyhedron K (= K1-K2), where K is m1m2. (M1: the number of grid points of K1; m2: the number of grid points of K2) is a convex polyhedron spanned by grid points {zi = xj-yk}. "

(B) Outline of Gilbert's Method From the conclusion in (a), the problem of finding the closest point between the two convex polyhedrons K1 and K2 results in the problem of finding the closest point from one point O to the convex polyhedron K. Is done. The Gilbert method uses this fact and a function called a support function described below. Support function hx for convex polyhedron
(η): R3 → R is defined below. 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
3 → R means conversion from three dimensions to one dimension. Therefore, the support function hx (η) in equation (6) means that, when the vector η is determined as shown in FIG. 71, the lattice point of the convex polyhedron X farthest from the origin in that direction is determined. ing. Now, assuming that a vector (position vector) from the coordinate origin O to this grid point is sx (η), the expression (6) is as follows.

Hx (η) = sx (η) · η (7) The calculation load of the closest approach point search by the Gilbert method is O (M1 + M
2). 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 K1 and K2. hk (η) = hk1 (η) + hk2 (−η), sk (η) = sk1 (η) −sk2 (−η) (8) The above equation shows the convex polyhedron K = K1-
This means that the support function for K2 is composed of the sum of the support functions for the convex polyhedrons K1 and K2.
Therefore, as is clear from the definition of the equation (6), the calculation load for calculating hx (η) is O (M1 + M2). The essence of the closest point search by the Gilbert method is that the support function hx (η) is repeatedly used to gradually approach the closest point. That is, the Gilbert method is composed of the following four processes.

(C) Algorithm for searching for the closest point by the Gilbert method 1) Initialization For the convex polyhedrons K1 and K2, the difference convex polyhedron K1-K2 is represented by K
And Take any points in the convex polyhedron K and call them y
1, y2... Yp∈K. In addition, y1, y2 ...
yp need not necessarily be the base lattice point of the convex polyhedron K. p is generally 1 ≦ p ≦ 4. At this time, a set Vk (= V0) of initial lattice points is set to Vk = {y1, y2... Yp}, k = 0.

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

3) Determination of closest approach point A function gK (x) from R3 to R is defined as follows. gK (x) = | x | 2 + hK (-x) In the above equation, the first term on the right-hand side means the square of the distance to the predetermined point on the convex polyhedron K, where x is the position vector, and the right-hand side The second term means an inner product of the lattice point position vector closest to the origin in the vector x direction and the vector -x. In other words, hK (-x) is the minimum value of the inner product of the position vector of the lattice point and x. gK
(x) is a determination function of the closest approach point. If x is the closest approach point from the origin O to K, and only then, gK (x)
= 0. It can be proved that gK (x) is a function for determining the closest approach point, but is omitted. See “IEEE JOUNAL
OF ROBOTICSAND AUTOMATION, VOL.4, NO.2, APRIL 198
8, pages 193-203, `` A Fast Procedure for Computing the Di
stance Between Complex Objects in Three-Dimensiona
l Space ”. From the above, if gK (νk) = 0 (10) with respect to νk determined by the equation (9), ν (K) = νk, and the closest approach point search processing is terminated.

4) Increment of k If equation (10) does not hold, k is incremented. That is, V (k + 1) is set as V (k + 1) = Vk′∪ ｛sK (−νk)] (11). Here, Vk ′ is Vk′⊆Vk, and
Vk is the minimum subset of Vk such that co∈Vk '. (1
Equation (1) expresses a subset Vk ′ (including νk) of Vk and Vk
Means the set including the minimum lattice point sK (−νk) closest to the origin in the direction of the closest point vector νk. As described above, if the expression (10) is not satisfied, k is incremented by the expression (11), the process returns to 2), and the subsequent processing is repeated until the expression (10) is satisfied.

(D) Application of nearest point search algorithm by Gilbert method The closest point search will be described with reference to FIG. 72 to deepen the understanding of the nearest point search algorithm by the Gilbert method. In FIG. 72, an initial value V0 = ｛z1, z2, z
3｝, and the closest point vector at V0 is ν
It becomes 0. At this time, since the expression (10) is not satisfied, k is incremented. V1 = V0 '{sk (-ν0)] = V0' {z4}, and since V0 '= {z2, z3}, V1 =
{Z2, z3, z4}. When the closest approach point vector in V1 is obtained, it becomes ν1. At this time, since the expression (10) is not satisfied, k is incremented.

V2 = V1'∪ ｛sk (-ν1)] = V
1 ′ {z5}, and since V1 ′ = {z3, z4}, V2 =
{Z3, z4, z5}. When the closest point vector at V1 is obtained, it becomes ν2. This ν2 satisfies the expression (10), and ν2 becomes the closest point vector, and ν2 = ν (K) ∈co {z4, z5}. As a result, the closest approach distance d is d = | ν2 |. Try the same with different initial values. In FIG. 72, when the initial value V0 = {z2} and the closest point vector at V0 is obtained, ν0 ′ (= z2). At this time, since the expression (10) is not satisfied, k is incremented. V1 = V0′∪ ｛sK (−ν0 ′)] = V0′∪ ｛z
5}, and since V0 '= {z2}, V1 = {z
2, z5}.

When the closest point vector at V1 is obtained, it becomes ν1 '. At this time, since the expression (10) is not satisfied, k is incremented. V2 = V1′∪ ｛sK (−ν1 ′)] = V1′∪ ｛z
4}, and since V1 ′ = {z2, z5}, V2 =
{Z2, z4, z5}. When the closest approach point vector in V2 is obtained, ν2 ′ (= ν2) is obtained.
Satisfies equation (10), and ν2 becomes the closest approach point vector, and ν2 ′ = ν2 = ν (K) ∈co {z4, z5}. As a result, the closest approach distance d is d = | ν2 |, and the same result as when the initial value V0 is set to V0 = {z1, z2, z3} is obtained.

(E) Discussion In the above algorithm, the computations required are (9) and (1)
0) and (11). First, equation (9) means that the point closest to a point, a side, a plane, or a tetrahedron from one point O is calculated. This part is not related to the complexity of the convex polyhedron, and can be executed by preparing a subroutine described later in advance. Next, the calculation of equation (10), gK (ν
In calculating hK (-νk) of k), the decomposition rule of equation (8) is used. This part is calculated only by evaluating the inner product of each convex polyhedron K1 and K2 with respect to the base lattice point (the inner product of the position vector of the base lattice point and νk), as shown in Expression (6). That is, hK (-νk) is to find the minimum of the inner product of the position vector of the base lattice point and νk, and therefore the calculation load of this part is O (M1 +
M2).

In the equation (11), sK (−νk) is obtained in the process of calculating gK (νk), and Vk ′ is automatically obtained from the lemma algorithm described later. Independent negligible constants (negligible c
onstant). The advantage of Gilbert's method is that it can reach the point of closest approach by repeating the above four processes 1) to 4) several times for almost all convex polyhedrons. In many cases, it has been confirmed by numerical experiments that the convergence is achieved by repeating 3 to 4 times. From the above, Gilber
In short, the essence of the closest point search method by the t method is
It can be summarized as follows. That is, two convex polyhedrons K
The closest point between K1 and K2 can be determined by repeatedly applying the judgment function gK (x) = | x | 2 + hK (-x) to the convex polyhedron K = K1-K2. And
The number of repetitions converges to 3 or 4 for most convex polyhedrons.

The initial lattice point (initial value) of the Gilbert method
Although V0 is generally arbitrary, it is efficient to start from a lattice point in the gravity center difference direction of each convex polyhedron as described below. v0 = {sK (−zc1 + zc2)} (12) Here, zc1 and zc2 are respectively zc1 = Σ (xi /
M1) (i = 1 to M1) xi: Base lattice point of convex polyhedron K1 zc2 = Σ (yi / M2) (i = 1 to M2) yi: Base lattice point of convex polyhedron K2

(F) The lemma of the Gilbert method In step 2) of the Gilbert method, the point of closest approach from one point (origin O) to a convex polyhedron (point, side, surface, tetrahedron) spanning four or less grid points An algorithm for finding a vector was needed. The lemma described below also holds for a convex polyhedron spanned by five or more grid points, but is particularly efficient when the number of grid points is small. 1) Lemma 1 For a lattice point set Y = {y1, y2,... Ym} R3, an arbitrary subset of Y is represented by Ys = [yi: i {Is {1,2,. ｝, The complement of Is is Is'. At this time, the sequence Δi (Ys) is created based on the following rule. Δi (｛yi)) = 1, i∈Is Δj (Ys∪ ｛yj｝) = ΣΔi (Ys) (yiyk−yi
yj) (i∈Is) where k = min ｛i: i∈Is｝, j
∈Is At this time, a subset of Y satisfying the following property is Ys. (1) Δi (Ys)> 0 for each i where i∈Is
(I∈Is) (2) For each j where j∈Is, Δj (Ys∪ ｛y
j｝) ≦ 0 (j∈Is)

2) Lemma 2 For a set of lattice points Y = {y1, y2,. (Co Y), ν (c
o Y) is given by the following formula: ν (co Y) = {λiyi, i∈Is⊆ ｛1, 2,...
Here, the proportionality constant λi is the subset Ys obtained in Lemma 1.
Is given by the following equation using Δi (Ys) for λi = Δi (Ys) / Δ (Ys), Ys = ｛yi: i∈I
s｝ Δ (Ys) = ΣΔi (Ys) (i∈Is) Although the detailed proof of the above lemma is omitted here, the meaning of the lemma can be easily understood. Let's apply the above lemma to a tetrahedron. As shown in FIGS. 73 (a) to 73 (d), the closest approach vector between the one point O and the tetrahedron is represented by each lattice point, side,
It may be in a plane or inside a tetrahedron. Therefore, if the subset Ys of Y consists of one point,
The case of two points corresponds to the case where the closest point exists on the side, and the case of three points corresponds to the case where the closest approach point exists on the surface. The case of four points corresponds to the case where the origin O exists inside the tetrahedron. .

When Lemma 1 and 2 are actually executed, the following algorithm is used. (g) The lemma algorithm of the Gilbert method For a lattice point set Y = ｛y1, y2,... ym｝ ∈R3, a subset of Y is represented by Ys = [yi: i∈Is⊆ ｛1,2,2,
... m｝｝, the complement of Is is Is'. Also, s =
.. Σ indicate all subsets of Y. At this time, the algorithm 2) of the Gilbert method is as follows.

2) 1 1 → s 2) 2 For each i of i∈Is, Δi (Ys)> 0 (i∈Is) and for each j of j∈Is If Δj (Ys∪ ｛yj｝) ≦ 0 (j∈Is), λi = Δi (Ys) / Δ (Ys), Ys = [yi: i
∈Is｝ Δ (Ys) = ΣΔi (Ys) (i∈Is) ν (co Y) = Σλiyi (i∈Is) (12) ′, and then execute the algorithm 3) of the Gilbert method. 2) 3 However, if the condition of 2) 2 is not satisfied, s is incremented and step 2) 2 is executed. That is, 2)
Steps 2), 2) and 3) are repeated until the condition 2 is satisfied. When the condition 2) is satisfied, ν (co Y) is calculated, and thereafter the algorithm 3) of the Gilbert method is executed.

(I) Numerical test The closest point search algorithm by the Gilbert method can be summarized into a subroutine having the following inputs and outputs. Input: Coordinate values of each lattice point of the biconvex polyhedron Output: Coordinate values of the closest approach point, closest approach distance FIG. 74 is a numerical test example in which the Gilbert method is executed in Fortran and applied to various convex polyhedrons. An asterisk indicates a case where two objects are approaching (free), an open circle indicates a case where the two objects are in contact, and a square black mark indicates a case where the two objects are interfering. The computer used was a Harris 800, which is a bit faster than the VAX 780 and has the performance of a current personal computer.

In FIG. 74, M shown on the horizontal axis is the number of grid points, and EF shown on the vertical axis is an amount defined by the following equation. EF = (tMNM + tANA + tDND + tCNC) / (tM + tA) (13) Here, NM is the number of integrations, NA is the number of additions, ND is the number of divisions, and NC is the number of comparison operations, and tM, tA, tD, and tC are required calculations. Time, and in the case of Harris 800,
tM = 3.8 μs, tA = 2.1 μs, tD = 6.7 μs, tC = 1.7 μs
It is. The value of EF does not vary greatly depending on the computer, and can be used as a machine independent index. In the case of Harris 800, the value obtained by multiplying EF by 6/106 corresponds to the CPU scale. Sparc chip (C
In the case of a workstation using a PU chip), a speed of one digit or more can be expected.

(J) Conclusion 1) From the above, the search for the closest approach point by the Gilbert method is performed when the total number of lattice points of two convex polyhedrons is M, when there is interference, when there is contact, and when free. Each has a computational load approximately proportional to M, and the proportionality constant is EF
The value falls within the range of 14 to 19 in terms of the value of / M. 2) When the Gilbert method is applied to two convex polyhedrons on a workstation of about 1M Flops, even if the total number of grid points is about 200,
The closest approach point can be calculated in ms.

[0033]

As described above, according to the Gilbert method, there is an effect that the closest point search between two objects can be efficiently executed in a short time. However, the Gilbert method has the following limitations or restrictions. 1) Limit of Gilbert's method: Support for continuous search problem Consider the case where the closest point between two convex polyhedrons is continuously chased. The problem of continuously following the point of closest approach between two convex polyhedrons is called a continuous search problem. With the movement of the object, the point of closest approach transitions in each convex polyhedron so as to walk from the surface to the side, from the side to the vertex, and from the vertex to the surface. Therefore, if the closest point is obtained at a certain point in time, the closest point at the next point in time should be near the previous closest point. In other words, the search for the point of closest approach is a local problem and should be independent of the complexity of the entire convex polyhedron.

However, in the Gilbert method, in the continuous search problem, the closest approach search processing considering all grid points is performed.
O (M1 + M
There is a problem that the calculation load of 2) is required every time the closest approach point is searched. In addition, since the calculation load is large, there is a problem that the closest approach point search process cannot be completed when the robot or the self-propelled vehicle moves at high speed.

2) Restriction of Gilbert's method: correspondence to non-convex polyhedron Gilbert's method is an algorithm for searching for the closest point between convex polyhedrons. For this reason, in order to increase the practicality, it is necessary to expand the object to a non-convex polyhedron, a non-single connected polyhedron, and an object having a free-form surface. When the closest point search between non-convex polyhedrons is performed by the Gilbert method, as shown in FIG. 75, each non-convex polyhedron K1, K2 is divided into a plurality of convex polyhedrons A, B; a, b, c, The closest point search algorithm is applied to all combinations of convex polyhedrons, and the shortest one among the obtained closest distances is selected. However, this method has a problem that the number of combinations increases and the calculation load increases. Accordingly, an object of the present invention is to provide an apparatus for searching for a closest approach point which can execute a continuous search problem between objects at a high speed with a small calculation load. Another object of the present invention is to provide an apparatus for searching for a point of closest approach that can execute a search for a point of closest approach between objects of at least one of which is a non-convex polyhedron at a high speed with a small calculation load.

[0036]

FIG. 1 is a diagram illustrating the principle of the present invention. In FIG. 1, reference numeral 22a denotes a polygon data storage unit for storing all polygon data covering two convex polyhedrons of interest, 22b a linear list storage unit for adjacent points, and 24 a vertex of each polygon in a first direction (next direction). A proximity point linear list creation unit that creates a proximity point linear list having a data structure in which a vertex group linked to each vertex via a polygon side is linked to the vertex in a second direction (branch direction); Reference numeral 26 denotes a closest approach point search processing unit.

[0037]

When the interference between the convex polyhedrons is checked by continuously searching for the closest point between the convex polyhedrons, the vertex coordinates of all the polygons covering the convex polyhedron are input and stored in the polygon data storage unit 22a. The proximity point linear list creation unit 24 links the vertices of each polygon in a first direction (next direction),
A near point linear list having a data structure in which a vertex group connected to each vertex via a polygon side is linked to the vertex in the second direction (branch direction) is created before executing the closest point search processing. Then, the closest approach point search processing unit 26
Calculates the vertices that are closest to the closest point obtained the latest from the close-point linear list, searches the vertices for the closest point at the next time, and performs an interference check.

When the interference check between the first and second non-convex polyhedrons is performed, each non-convex polyhedron is decomposed into convex polyhedrons, and the closest approach point between the convex polyhedrons is continuously searched for. Check for interference between the two. In order to check for interference between the respective convex polyhedrons, the proximity point linear list creating unit 24 links the vertices of all the polygons covering the convex polyhedron in the first direction (next direction) in advance for each convex polyhedron. A proximity point linear list having a data structure in which a vertex group connected to a vertex via a polygon side is linked to the vertex in a second direction (branch direction) is created. The closest point search processing unit 26 obtains, for each of the non-convex polyhedrons, the maximum coordinate value and the minimum coordinate value in each axis direction among the vertex coordinate values of the non-convex polyhedron, and calculates the non-convex polyhedron based on the maximum coordinate value and the minimum coordinate value. An envelope sphere enclosing the convex polyhedron is generated, and it is checked whether the envelope spheres of the first and second non-convex polyhedrons interfere with each other. After the interference, the maximum between the convex polyhedrons obtained by decomposing the non-convex polyhedron is obtained. The approach point is searched for, and the vertices closest to the closest approach point that has been obtained latest are obtained from the above-mentioned proximity point linear list, the closest approach point at the next time is searched from these vertices, and the closest approach between each convex polyhedron is obtained. An interference check is performed using the one having the shortest point-to-point distance.

When the interference check between the first and second non-convex polyhedrons is performed, each non-convex polyhedron is decomposed into convex polyhedrons, and the point of closest approach between the convex polyhedrons is continuously searched for. Check for interference between the two. In order to check for interference between the respective convex polyhedrons, the proximity point linear list creating unit 24 links the vertices of all the polygons covering the convex polyhedron in the first direction (next direction) in advance for each convex polyhedron. A proximity point linear list having a data structure in which a vertex group connected to a vertex via a polygon side is linked to the vertex in a second direction (branch direction) is created. The closest point search processing unit 26 generates a minimum convex polyhedron (convex hull) wrapping each non-convex polyhedron, checks whether the convex hulls of the first and second non-convex polyhedrons interfere, and after the interference, The closest point between the convex polyhedrons is searched for, the vertices close to the closest point obtained the latest are obtained from the close point linear list, and the closest point at the next time is searched from these vertices, and each convex point is searched. An interference check is performed using the shortest distance between the closest points between the polyhedrons.

[0040]

DESCRIPTION OF THE PREFERRED EMBODIMENTS (A) First method of searching for the closest point between convex polyhedrons (a) Principle The process of generating an O (M1 + M2) computational load by the Gilbert method is a judgment function gK ( νk) hK
This is in calculating the inner product of (−νk). That is, hK
(−νk) is calculated from the equation (8) as follows. .Nu.k: i = 1, 2,... M2] (14) Therefore, in the process of evaluating hK, the convex polyhedrons K1, K2
Since the inner product over all the grid points is calculated to determine the minimum one, a calculation load of O (M1 + M2) occurs.

An effective measure to reduce the number of calculations of inner products is to divide the convex polyhedrons K1 and K2 into convex polyhedrons or convex polygons having a smaller number of grid points, and to divide the convex polyhedron or convex polyhedron located near the current closest point. This is a method of evaluating the inner product only for a square.

The simplest division method is as shown in FIG.
This is a method of dividing a convex polyhedron into a set of surface polygons. At this time, the closest approach point in the convex polyhedron can be one of three cases: 1) existing on a grid point, 2) existing on a side, and 3) existing on a surface.

Therefore, the surface polygon for which the inner product is evaluated for each of them may be limited as follows. That is,
If the closest point is on a grid point, 1) all surface polygons having the grid point at the vertex; 2) if they are on a side, the surface polygon has the side as one side , 3) If it exists on the surface, the surface polygon on which the closest point is present ... (15) is the surface polygon for evaluating the inner product. That is, the inner product is evaluated only for the grid points (vertexes) constituting the surface polygon shown in 1) to 3) of (15) according to the position where the closest approach point exists (the grid point at which the inner product is minimized is determined). ), Judgment function gK
(Νk) may be calculated. By doing so, the number of grid points required for inner product evaluation is reduced, and the calculation load is reduced.

(B) Data Structure of Convex Polyhedron for Searching for Nearest Point In order to continuously obtain surface polygons required for inner product evaluation according to the above 1) to 3), a data structure for defining a convex polyhedron It needs some ingenuity. FIG. 3 shows an example of a data structure in the case of the hexahedron shown in FIG. 2, and employs directed graph type structure data.
This directed graph type structure data can be expressed as follows when abstracted.

1) The surface polygons constituting the convex polyhedron are numbered, and one polygon node is assigned to each polygon.
Assign 2) Below each polygon node, a lattice point node (Vertex node) for arranging all the grid points and all sides that make up the polygon
And an edge node. The set of grid points and the set of edges that make up the polygon are the brother node (brother nod) for the grid point node and the edge node, respectively.
e) exists as 3) Under the grid point node and the edge node, a polygon having those grid points or sides as constituent elements is allocated as a polygon node. If there are a plurality of polygons, they are assigned as brother nodes.

(C) Method for evaluating inner product of decision function gK (νk) As described above, when a data structure of a convex polyhedron is created, (1)
5) can be expressed as follows. The evaluation of hK (-νk) in the calculation of the judgment function gK (νk) is as follows. The inner product evaluation is performed on grid points of the surface polygon corresponding to the node. The inner product is evaluated with respect to the lattice points of the polygon. 3) If the closest point exists on the surface, the inner product is evaluated with respect to the lattice points of the surface. (15) 'When the inner product evaluation is restricted as shown in (15)', the calculation load of the judgment function gK (νk) is L with the maximum number of lattice points of the surface convex polygon of the convex polyhedron being L and Then, it can be suppressed to O (L) or less.

(D) Algorithm for Finding the Nearest Point Using the Inner Product Evaluation Method of the Present Invention FIG. 4 is a flowchart of the algorithm for finding the closest point between two convex polyhedrons according to the present invention. First, data for specifying two target convex polyhedrons is input (initial input: environment model setting of convex polyhedron). In this case, data specifying each convex polyhedron is input in the following manner (see FIG. 5). That is, a polygon number P1i (i = 1, 2,... M) is assigned to a surface polygon constituting the first convex polyhedron PH1. Then, the i-th polygon number P1i is input, and thereafter, the coordinate values of the grid points constituting the polygon number P1i and the outward normal direction of the polygon number P1i are input, and all polygons P1i are input.
Polygon number for 1i (i = 1, 2,... M),
Enter the coordinate values of the grid points and the outward normal direction. Note that the coordinate values of the grid points forming the polygon are input clockwise toward the outward normal vector.

Thereafter, similarly, polygon numbers P2i (i = 1, 2, 2) are assigned to surface polygons constituting the second convex polyhedron PH2.
.. N). Then, the i-th polygon number P2i
, And then input the coordinate values of the lattice points constituting the polygon number P2i and the outward normal direction of the polygon number P2i, and enter all the polygons P2i (i = 1, 2,... N).
, A polygon number, grid point coordinate values, and outward normal directions are input (step 101). When the input of the data for specifying each convex polyhedron is completed, directed graph type structure data is created based on the input data (step 10).
2). When the creation of the directed graph type structure data is completed, the Gilbert method is applied to the convex polyhedrons PH1 and PH2. First, an initial lattice point set Vk (k = 0) is determined (step 103), and the closest point vector νk is calculated and output for the initial lattice point set V0 (step 104).

Next, it is checked whether the closest point on each convex polyhedron PH1 or PH2 corresponding to the closest point is present on the lattice point, on the side, or on the surface. Grid points to be used for inner product evaluation are determined by
(Νk) is calculated (step 105). Note that if the lattice points on the convex polyhedron PH1 are x1i and the lattice points on the convex polyhedron PH2 are x2i, the expression (12) 'is expressed as follows. ∈Is) = Σλix1i−Σλix2i (i∈Is) (12) ″ The first term on the right side of (12) ″ is a position vector of the closest point on the convex polyhedron PH1, and the second term on the right side is the convex polyhedron. PH
2 is the position vector of the point of closest approach on FIG. Therefore, in the process of calculating the closest approach point vector νk, the first right side of the equation (12) ″
By calculating the term and the second term on the right side, the closest point on each convex polyhedron PH1, PH2 corresponding to the closest point vector can be obtained.

When the judgment function is obtained, it is checked whether gK (νk) = 0 (step 106). If gK (νk) = 0, the search for the closest approach point is completed. However, gK (νk)
Is not 0, k is incremented and the closest point vector is output for the next set of grid points V1 (step 107). Thereafter, by repeating the processing of step 105 and subsequent steps, gK (νk) becomes finally 0, and the closest approach distance and the closest approach point are obtained. That is, two convex polyhedrons PH1, P
The closest point vector to the difference set convex polyhedron of H2 is (12) '
Since it is obtained by the formula, the distance from the origin O to the closest point is the closest distance. Also, at this time, the first term on the right side of the equation (12) ″,
The closest point on each convex polyhedron PH1, PH2 can be obtained from the second term.

(E) Configuration diagram of the closest approach point search device employing the inner product evaluation method of the present invention FIG. 6 is a configuration diagram of the closest approach point search device between two convex polyhedrons. In the figure, 11 is an input unit for inputting data (see FIG. 5) for specifying two target polyhedrons, 12 is a storage unit for storing the input polyhedron data, and 13 is convex polyhedron data for each convex polyhedron A directed graph type structure data creating unit that creates directed graph type structure data by using, 14 is a storage unit that stores the directed graph type structure data, 15 is a closest approach point that performs a closest point search process between two objects based on the Gilbert method The search processing unit 16 reads, from the directed graph type structure data storage unit 14, a grid point for inner product evaluation corresponding to the position (grid point, side, surface) where the closest point exists, and inputs it to the closest point search processing unit 15. This is an inner product evaluation grid point reading unit.

Data for specifying the convex polyhedrons PH1 and PH2 is input from the input unit 11 and stored in the storage unit 12. The directed graph type structure data creating unit 13 creates directed graph type structure data based on the input data, and stores it in the storage unit 14. When the creation of the directed graph type structure data is completed, the closest approach point search processing unit 15 provides Gi for the convex polyhedrons PH1 and PH2.
Apply lbert method. First, an initial lattice point set Vk (k =
0) is determined, and the closest approach vector νk is calculated for the initial lattice point set V0. Next, the closest approach point on each convex polyhedron according to the closest approach vector νk is determined, and it is checked whether each closest approach point is on a lattice point, on a side, or on a surface. , Plane) are input to the inner product evaluation grid point reading unit 16. The reading unit 16 reads grid points used for inner product evaluation determined based on the position of the closest point from the directed graph type structure data storage unit 14 and inputs the lattice points to the closest point search processing unit 15. The closest point search processing unit 15 evaluates the inner product using the input lattice points and determines the judgment function gK
(Vk) is calculated. Then, if the decision function is found,
It is checked whether gK (νk) = 0. If gK (νk) = 0, the search for the closest approach point is finished, and the closest approach distance and the closest approach point are output. However, if gK (νk) is not 0, k is incremented and the closest point vector is output for the next set of grid points V1. Thereafter, the same processing is performed,
Finally, gK (νk) = 0, and the closest approach distance and the closest approach point are output. If the convex polyhedrons PH1 and PH2 move, the lattice point positions of the respective convex polyhedrons after the movement are obtained based on the movement data at predetermined time intervals, and the above processing is performed.

(B) Second method of searching for the closest point between convex polyhedrons (a) Principle In the first method of searching for the closest point, the convex polyhedron, which is the target object, is divided into surface convex polygons each wrapping it. The calculation load was on the order of the number of lattice points of the convex polygon. Further elaborating the concept of the first closest approach search method, it is clear that if the surface of the convex polygon is completely covered with the triangular polygon, the number of times of one inner product evaluation is minimized. Fig. 7 (a)
Is an explanatory view of a state in which the point of closest approach to the convex polyhedron K moves on the surface polygon in accordance with the movement of the origin O. Origin O
The point of closest approach S is a convex polygon P1 → a convex polygon P according to the movement of
2 → Continuously moves on the convex polygon P3. Therefore,
If the convex polygon is divided into triangles Tij as shown in FIG.
T12 → T21 → T22 → T23 → T24 → T25 → T
26 → Continuously changes on T31.

Therefore, there is no problem even if all the surface convex polygons constituting the convex polyhedron are divided into triangles and the first closest approach search processing is performed. Then, by dividing into triangles, the number of times of one inner product evaluation can be reduced. For example, assuming that the closest point S ′ exists on the side E11 in FIGS. 7A and 7B, in the case of FIG. 7A, the grid points used for inner product evaluation are V1 to V6. There are six, but in the case of FIG. 7 (b), only four of V1, V3, V4, and V6 are sufficient, and the number of times of one inner product evaluation can be reduced. As described above, if the target convex polyhedron is subjected to preprocessing to form a data structure in which all the surface convex polygons are divided into triangular polygons, the calculation load in the case of continuously evaluating gK (νk) becomes an object. It can be kept below a certain value regardless of the complexity of the convex polyhedron.

Several algorithms for dividing an arbitrary convex polygon into triangular polygons are known in the field of computational geometry. The best known method is triangulation, which uses dynamic programming to minimize the sum of chord lengths. FIG. 8 shows an example. The strings are L1 to L6
Is a line segment for dividing into triangles as shown in FIG. The calculation load of this algorithm is O (n3), where n is the number of grid points of the first polygon. For an algorithm to convert polygons into triangles, see Tetsuo Asano, "Computational Geometry" (Asakura Shoten), Te. Asano, Ta. Asano and Y. Ohsuga: "Partitio
ning a Polygonal Region into a Minimum Number of T
riangles ", Trans. IECE of Japan, vol.E67, pp.232〜
See 233, 1984.

As described above, the method for dealing with the continuous search for the closest approach point (second closest approach search method) can be summarized as follows. 1) Preprocessing 1: Triangulation of each surface convex polygon surrounding the target convex polyhedron (Triangulation algorithm) 2) Preprocessing 2: Directed graph as in the first closest point search method using triangles Create type structure data. 3) Inner product evaluation: The range of inner product evaluation in gK (νk) is limited according to (15) ′.

(B) Second Nearest Point Search Algorithm of the Present Invention FIG. 9 is a flowchart of the closest point search algorithm according to the second closest point search method of the present invention. First, data for specifying two target convex polyhedrons is input (initial input: environment model setting of convex polyhedron). Data for specifying each convex polyhedron is input in the following manner (see FIG. 5). That is,
The number P1 is assigned to the surface polygon constituting the first convex polyhedron PH1.
i (i = 1, 2,... m) is attached. Then, the i-th polygon number P1i is input, and thereafter, the coordinate values of the lattice points constituting the polygon of the number P1i and the outward normal direction of the polygon are input, and similarly, all the polygons P1i (i =
For 1, 2,... M), a polygon number, grid point coordinate values, and outward normal directions are input. Note that the coordinate values of the grid points forming the polygon are input clockwise toward the outward normal vector. Similarly, the polygon numbers P2i (i = 1, 2,...) Are assigned to the surface polygons constituting the second convex polyhedron PH2.
・ ・ N) Then, the i-th polygon number P2i is input, and thereafter, the coordinate values of the grid points constituting the polygon number P2i and the outward normal direction of the polygon number P2i are input, and all polygons P2i (i = 1, 2,. .. N), a polygon number, grid point coordinate values, and outward normal directions are input (step 201).

When the input of the data for specifying each convex polyhedron is completed, the surface convex polygon constituting the convex polyhedron is divided into triangles based on the input data, and each triangle has a polygon number T.
ij is added (step 202). Next, the obtained triangle is used as a polygon node to create directed graph type structure data in the same manner as in the first closest point search method (step 203). When the creation of the data of the directed graph structure is completed, the Gilbert method is applied to the convex polyhedrons PH1 and PH2. First, an initial lattice point set Vk (k = 0) is determined (step 204), and the closest point vector vk is calculated and output for the initial lattice point set V0 (step 20).
5).

Next, the closest point on each convex polyhedron according to the closest point vector νk is determined, and it is checked whether each closest point exists on a lattice point, on a side, or on a surface. Based on (15) ', a grid point used for inner product evaluation is determined based on (15)', and a judgment function gK (νk) is calculated (step 2).
06). If the judgment function is obtained, it is checked whether gK (νk) = 0 (step 207). If gK (νk) = 0, the search for the closest approach point is completed. However, gK (νk) is 0
Otherwise, k is incremented and the next set of grid points V
1 is output as the closest approach point vector (step 20).
8). Thereafter, by repeating the processing of step 105 and subsequent steps, gK (νk) becomes finally 0, and the closest approach distance and the closest approach point are obtained. If the convex polyhedrons PH1 and PH2 move,
Based on the movement data for each predetermined time, the lattice point position of each convex polyhedron after movement is obtained, and the above processing is performed.

(C) Configuration of Second Nearest-Point Searching Apparatus of the Present Invention FIG. 10 is a block diagram of an apparatus for implementing the second closest-point searching method of the present invention. Have the same reference numerals. 6 is different from FIG. 6 in that 1) a triangular division unit 17 is provided to divide the surface convex polygons constituting the convex polyhedron into triangles based on the convex polyhedron data specifying the convex polyhedron. 2) Directed graph type The structure data creation unit 13 creates directed graph type structure data using each triangle as a polygon node, and stores it in the storage unit 14.

(D) Effects of the second closest approach point searching method According to the second closest approach point searching method, the following effects 1) and 2) can be obtained. 1) High speed: When following the closest approach point continuously, the calculation load can be kept almost constant regardless of the complexity of the target convex polyhedron except for the time required for initialization. The constant value is substantially equal to the time for searching for the closest point between the triangular polygons. 2) Application to free-form surfaces: When a free-form surface is expressed by laminating triangular polygons, the time for searching for the closest approach point is always constant even if the number of polygons is increased in order to increase the accuracy of the expression.

(C) First Search for Nearest Point between Nonconvex Polyhedrons
(A) Principle The basic principle of extending the Gilbert method to a non-convex polyhedron is that when a non-convex polyhedron is regarded as a set of convex polyhedrons, the number of combinations of convex polyhedrons that must be checked for interference is It is to reduce. Of course, the Gilbert method is used to check for interference between convex polyhedrons. Merging (mergin) for multiple convex polyhedra to reduce the number of convex polyhedra
Introduce the concept of g). The merging of the object A and the object B is the smallest convex object including A and B (Copnvex hull: convex hull)
It is to constitute. FIG. 11 shows that the non-convex polyhedron K is divided into two convex polyhedrons A and B, and A and B are merged.
This is an example in which a minimum convex object (convex hull) C including the following is configured. When the convex hull is generated, the interference check of the non-convex polyhedron results in the interference check of the convex hulls (convex polyhedrons), and the first closest point search method of the present invention can be applied.

In constructing the convex hull C, an index called virtuality is introduced. The virtuality is a flag for identifying a virtual polygon generated by merging a plurality of convex polyhedrons. In the example of FIG. 11, the virtuality is "for a polygon (polygons 4, 5, 6) extending over two existing convex polyhedrons (cuboids) A and B.
1 ”, and the virtuality is“ 0 ”for other actually existing polygons. Creates effective graph type structure data of a convex hull.FIG. 12 shows directed graph type structure data of a convex hull shown in FIG. A grid point node and an edge node are arranged below, and a polygon node is arranged below each grid point node and the edge node.

(B) Merging Algorithm FIG. 13 is a flowchart of the merging algorithm. The target non-convex polyhedron is divided into two or more convex polyhedrons, and data specifying each convex polyhedron is input (initial input: environment model setting of the convex polyhedron). That is, the first convex polyhedron PH1
Are assigned polygon numbers P1i (i = 1,
2,... M). Then, the i-th polygon number P
1i, and thereafter, the coordinate values of the lattice points forming the polygon number P1i and the outward normal direction of the polygon number P1i are input, and all polygons P1i (i = 1, 2,...) Are input.
For m), a polygon number, grid point coordinate values, and outward normal directions are input. Hereafter, similarly, polygon numbers P2i (i = 1,
2,... N) and all polygons P2i (i = 1, 2)
2,... N), polygon numbers, grid point coordinate values,
An outward normal direction is input (step 301).

When the input of the data for specifying each convex polyhedron is completed, data of a directed graph structure is created based on the input data (step 302). Next, the smallest convex hull PH (1,2) including each convex polyhedron PH1, PH2 is generated (step 303). After that, the polygon number PPH (1,2) i (i = i) is assigned to the surface polygon forming the convex hull PH (1,2).
1, 2,... R) and the i-th polygon number PPH (1, 2)
After inputting i, coordinate values of grid points constituting the i-th polygon,
The virtuality and outward normal direction of the polygon are obtained and stored (see FIG. 14). Thereafter, similarly, when the polygon number, the grid point coordinate value, and the virtual normal outward direction are obtained for all the polygons PPH (1, 2) i (i = 1, 2,... R), the convex graph directional graph is obtained. Type structure data is created and stored in memory. The polygon PPH
If (1,2) i includes both lattice points of the convex polyhedron PH1, PH2, the virtuality is "1", and if it includes only one lattice point, the virtuality is "0" ( Steps 304 and 305).

The merging algorithm is an algorithm for creating a convex hull from a plurality of convex polyhedrons and creating directed graph type structure data. Algorithms for creating convex hulls are well known in computational geometry. For the current three-dimensional convex hull, if the total number of grid points is M, the computational load is O (M
The algorithm of log M) is known. For example, F.
P. Preparata and SJ Hong, "Convex hulls of finit
e sets of points intwo and three dimensions ", Com
m. See ACM 2 (20), pp. 87-93, 1977. The merging algorithm operates on relatively stationary convex polyhedrons, and cancels merging when the polygon of virtuality "1" comes into contact with or collides with another object. As a result, the closest point search process is performed on the set state of the lower convex polyhedron. Further, after the merging is released (after the convex hull is released), if there is no interference with another object for a certain period of time, the convex hull decomposed by the interference is recovered by a recovery algorithm (described later).

(C) Activating the Merging Algorithm The merging algorithm is applied to the target object offline in the initial setting, and when the environment starts to change dynamically, that is, a certain convex polyhedron in the environment If has started, the merging process stops temporarily while maintaining the current state, and performs an interference check. Then, when the environment is stopped, a merging process is executed to create a convex hull after the environment is changed, and to create a directed graph type structure data of the convex hull. FIG. 15 is an explanatory diagram of merging processing by the processor in consideration of the above. A flag ms (i) for monitoring the static movement of the convex hull is prepared for all convex hulls. If the static motion flag ms (i) = "1", it is dynamic, ms (i)
== "0" is static and i spans all convex hulls.

As a task of the processor, all m
A state monitoring task Task1 that monitors the value of s (i) to monitor the static motion state of the convex hull, and the first closest approach point search method described above when any of ms (i) is “1”. Task2 (an interference check task) for executing other processing for interference check, and Task3 (merging task) for executing a merging process when all ms (i) = "0", that is, when all convex hulls are stationary. ). The static state of all convex hulls is monitored by a robot controller (not shown), and ms (i) = "1" or ms (i) is stored in the memory MEM.
= "0". Status monitoring task Task
1 monitors the contents of ms (i), and if all are "0", a merging task Task3 is activated to execute a merging process to create a convex hull and create directed graph type structure data. The merging task Task3 stops when one convex hull is formed, and waits for the next activation instruction. On the other hand, any m
When s (i) is “1”, in other words, when any convex hull is moving, the interference check task Task2
Performs the interference check and other processing by the first closest approach point search method. Thereafter, the above operation is repeated to execute the interference check.

The above is a case where merging processing, interference check processing, and the like are executed by task switching.
The merging process can be performed sequentially using an ile statement. FIG. 16 is an explanatory diagram of a case where a merging process is executed using a While sentence. While
In the sentence, it is monitored whether ms (i) of all convex hulls is "0", and if all are "0", a merging process is executed to create one convex hull (step 401). After a while, Wh
The ile sentence is escaped, interference check and other processing are executed (step 402), and the While sentence is executed again.
Thereafter, the merging process and the interference check process are repeatedly and continuously executed.

When the environment changes dynamically, for example, FIG.
When the robot arm AM passes through the arch AC, which is a non-convex polyhedron, and grasps the object OB on the opposite side as shown in (1), the arm AM breaks through the convex hull formed by the arch AC and reaches the object OB. In this case, merging is canceled when the robot arm AM comes into contact with the convex polygon of the virtual hull “1” of the convex hull. After that, the individual convex polyhedrons AC1 to AC1 constituting the robot arm AM and the arch AC will be described.
An interference check with AC3 is performed, and the robot arm reaches the object OB so as not to contact the arch AC, and grabs the object and transports it to a target location. The convex hull from which merging has been canceled is restored by a recovery algorithm described below. FIG. 18A shows a convex hull CH on the worktable BS and the arch AC.
FIG. 18B shows an example in which an arch AC and an object O are generated.
This is an example in which convex hulls CH2 and CH3 are generated for each of B. As shown in FIG. 18C, the robot arm AM has a convex hull CH1 composed of a worktable BS and an arch AC, and a convex hull composed of an arch. Object OB by piercing the parcel CH2 one after another
, And grasps and transports the object to a target location.

(D) Recovery Algorithm The convex hull decomposed by the interference recovers when there is no interference with another object for a certain period of time. The recovery process operates only on the convex hull in which the data structure in the merging state remains. Therefore, a convex polyhedron set in which the relative positional relationship has moved and the original data structure of the convex hull has been lost is not recovered by the recovery processing, and a new convex hull is formed by applying the merging algorithm.

FIG. 19 is an explanatory diagram of merging processing and recovery processing by the processor. A flag ms (i) for monitoring the static movement of the convex hull is prepared for all convex hulls. If the static motion flag ms (i) = "1", it is dynamic, ms (i)
== "0" is static and i spans all convex hulls. As a task of the processor, a state monitoring task Tas that constantly monitors all values of ms (i) to monitor the static state of the convex hull.
k1 and Task2 (interference check / recovery task) for executing interference check processing, recovery processing, and other processing by the first closest approach point search method when any of ms (i) is “1”; Task3 (merging task) for executing the merging process when ms (i) = “0”, that is, when all the convex hulls are stationary.

The stationary state of all the convex hulls is monitored by a robot controller (not shown), and ms (i) = “
It is written as 1 "or ms (i) =" 0 ". The status monitoring task Task1 monitors the contents of ms (i), and when all are" 0 ", the merging task Task3 is activated. The processing is executed to create a convex hull and create directed graph type structure data.The merging task Task3 stops when one convex hull is formed, and waits for the next activation instruction.
When s (i) is “1”, in other words, when any convex hull is moving, the interference check task Task2
Executes the interference check by the first closest approach point search method, and executes the recovery process and other processes. Thereafter, the above operation is repeated to execute the interference check.

In the recovery process, a convex hull virtuality is used.
When the merging is released by contact of the convex polygon of 1 "with another object, monitoring whether the convex hull no longer interferes with the object,
If no interference continues for a predetermined time after the interference stops, the convex hull is restored. In the example of FIG. 17, when the robot arm AM grasps the object OB and passes through the arch AC, interference between the convex hull and the arm disappears.

The above is a case where the recovery processing is executed by switching tasks, but the recovery processing can be performed sequentially using a While statement. FIG.
0 is an explanatory diagram in the case where recovery processing is executed using a While statement. M of all convex hulls in a While sentence
It monitors whether s (i) is "0", and if all are "0", executes a merging process to create one convex hull (step 501). Thereafter, the While sentence is escaped, interference check processing, recovery processing, and other processing are executed (step 502), and the While sentence is executed again. Thereafter, the merging process, the interference check process, and the recovery process are repeatedly and continuously executed.

(E) Overall processing for searching for the closest point between non-convex polyhedrons FIG. 21 is an overall processing flowchart for searching for the closest point between non-convex polyhedrons. Input data specifying the target non-convex polyhedron (initial input: environment model setting). Step 601 Next, the non-convex polyhedron is divided into convex polyhedrons, and each convex polyhedron P
Create directed graph type structure data of Hi. Further, a convex hull is generated by the merging process, and directed graph type structure data of the convex hull is generated (step 602). When the above initialization processing is completed, a first closest point search processing (interference check) processing is executed (step 603). Next, it is checked whether or not interference occurs (step 604). If there is interference, it is checked whether or not the portion of virtuality = “1” has interfered (step 605). In step 606), if the virtuality is "1", merging is canceled (step 607), and the process returns to step 603. Thereafter, until the convex hull is recovered, the closest approach point search processing is executed for each convex polyhedron constituting the non-convex polyhedron.

On the other hand, in step 604, if there is no interference, a recovery process is executed (step 60).
6). In the recovery process, it is checked whether or not the convex hull whose merging has been canceled exists. If there is, it is checked whether or not it interferes with another object. Then, if the non-interference time of the convex hull whose merging has been canceled is equal to or longer than the set value, the convex hull is restored. However, if it interferes with another object or the non-interference time is not longer than the set value, the next step is executed without restoring the convex hull. If the original convex hull data is lost due to a change in the relative positional relationship between the parts constituting the convex hull, the convex hull is not restored. Next, it is checked whether all parts of the convex hull are stationary (step 609). If not stationary, the process returns to step 603 and the subsequent processing is repeated. A convex hull is created (step 610), and the process returns to step 603 to repeat the subsequent processes.

(F) Configuration of apparatus for searching for points of closest approach between non-convex polyhedrons FIG. 22 is a block diagram of an apparatus for searching for points of closest approach between non-convex polyhedrons. Reference numeral 21 denotes an input unit for inputting data for specifying a target non-convex polyhedron, reference numeral 22 denotes a storage unit for storing the input non-convex polyhedron data, and reference numeral 23 divides the non-convex polyhedron into a plurality of convex polyhedrons. A convex polyhedron division / directed graph creation unit for creating directed graph type structure data for each, a convex hull creation / directed graph creation unit for creating a convex hull of a non-convex polyhedron and creating directed graph type structure data of the convex hull, 25 A storage unit for storing the directional graph type structure data CVD of each convex polyhedron and the directional graph type structure data CHD of the convex hull, a processor 26 for performing state monitoring, interference check, merging and recovery processing, and a controller 27 sent from the robot controller A memory 28 stores the static motion flag ms (i) and the position data of each object. A memory 28 stores, for each convex hull, whether or not merging of the convex hull is canceled. That.

Data for specifying the target non-convex polyhedron is input from the input unit 21 and stored in the memory 22. The convex polyhedron division / directed graph creation unit 23 divides a non-convex polyhedron into convex polyhedrons, and generates a directed graph type structure data CVD of each convex polyhedron.
Is created and stored in the memory 25. In addition, the convex hull creation / directed graph creation unit 24 creates a convex hull by merging processing, creates directed graph type structure data CHD of the convex hull, and stores it in the memory 25.

When the above initialization processing is completed, the processor 26 executes the above-described first closest approach point search processing (interference check) processing using the directed graph type structural data of the convex hull. For a moving object, a grid point position is calculated based on movement data input from the robot control device,
The closest point search processing is performed based on the grid point position. Convex hull (virtuality = "1") by closest point search processing
When the interference with the hull is detected, the merging of the convex hull is released, and the release flag FR = "1" is stored in the memory 28.
Thereafter, the processor 26 checks whether or not the convex hull has been recovered by referring to the release flag FR. Execute. In addition, the processor 26 executes the recovery process if it does not interfere with the convex hull (virtuality = “1”).

In the recovery processing, the release flag memory 28 is referenced to check whether or not a convex hull whose merging has been released exists. If there is, it is checked whether or not it interferes with another object. For example, the non-interference time T is measured. Then, if the non-interference time T of the convex hull from which merging has been canceled is equal to or longer than the set value, the convex hull is restored. That is, the release flag FR is set to 0. However, the convex hull is not restored when it interferes with another object or when the non-interference time is not longer than the set value. Then, referring to the stationary flag ms (i) input from the robot controller, it is checked whether all of the convex hulls are stationary, and if not, the above interference check is repeated. When stationary, when the relative positional relationship of the convex polyhedrons constituting the non-convex polyhedron is changing, a merging process is executed to create a new convex hull, store it in the memory 25, and thereafter, Repeat the process.

As described above, according to the method of searching for the closest point between non-convex polyhedrons according to the present invention, a convex hull is created, directed graph-type structure data of the convex hull is created, and based on the directed graph-type structure data of the convex hull. The closest approach point search process.
The number of combinations of convex polyhedrons can be greatly reduced.
Also, if the convex hull collapses due to the dynamic change of the environment, the original convex hull will be restored if there is no interference with other objects for a certain period of time, and the number of convex polyhedrons will be minimized. Can be maintained and the computational load can be reduced.

(D) First Method in Continuous Search for Nearest Points between Nonconvex Polyhedrons (a) Principle In the “continuous search for closest points”, which continuously tracks the closest points between a plurality of nonconvex polyhedrons The merging process is performed on each of the non-convex polyhedrons to reduce and solve the continuity problem of the points of closest approach between the formal convex polyhedrons. At this time, for each convex polyhedron obtained by merging, numbers are assigned to surface convex polygons constituting the convex polyhedron, and lattice points, sides, and convex polygons located near each convex polygon are registered. Create a directed graph type structure data and calculate the calculation load of the closest point search by the order O of the maximum value of the number of grid points of the surface polygon.
(L) Keep below. In merging, an index called virtuality is introduced. What is virtuality?
In the surface polygon of the convex polyhedron obtained in the process of merging, if the surface polygon of the original non-convex polyhedron matches, the virtuality is set to 0, and if not, the virtuality is set to 1.

When interference with the convex polygon of virtuality = 1 occurs, merging is canceled and the first polyhedron of the present invention in the convex polyhedron is compared with the combination between the convex polyhedrons constituting the original non-convex polyhedron. The method of searching for the closest point is applied.
The rules for canceling merging are as follows. 1) If a polygon with virtuality = 1 (a component of convex hull A) and a polygon with virtuality = 0 (a component of convex hull B) interfere with each other, a convex hull A having a polygon with virtuality = 1 is generated. To release. 2) If the polygon with virtuality = 1 (the component of the convex hull A) and the polygon with the virtuality = 1 (the component of the convex hull B) interfere with each other, the constituent convex polyhedron when the convex hull is decomposed into a convex polyhedron Release the smaller number of convex hulls. 3) If the polygons with virtuality = 0 interfere with each other, neither convex hull is released.

As shown in FIG. 23, if the convex hull A and the convex hull B interfere with each other (see (b)), and the convex hull A is released and a set DA (Decomposed A) of constituent convex polyhedrons appears (( c)).
The first closest point search method of the present invention in the convex polyhedron between the set DA and the convex hull B is applied. The algorithm in this case is as follows. (b) Algorithm for searching for the point of closest approach between the convex polyhedron set and the convex hull 1) The interference surface of convex hull A when convex hull A is released is defined as PA (Virt
uality (PA) = 1). At this time, each side of the interference plane PA is composed of an element Edge (DA, PA) of the set DA and a side of virtuality = 1, and the lattice points of the interference plane PA are elements of the set DA
x (DA, PA).

2) The interference check between the set DA of the constituent convex polyhedron and the convex hull B is performed by Edge (DA, PA), Vertex (DA, PA) and convex hull B
This is performed by applying the first closest approach point search method of the present invention in a convex polyhedron. That is, Edge (DA, PA),
The surface convex polygon of DA including Vertex (DA, PA) (see the shaded portion of (c)) is converted to each convex polyhedron (A ′,
A ″) is searched from the directed graph type structure data.Then, the interference check is performed by applying the first closest approach point search method in parallel between the surface polygon and the convex hull B obtained respectively ((d)). 3) If the state escapes from the state of interference with the convex polygon of virtuality = 1, the convex hull released by the recovery processing is recovered, and the closest approach point search processing is performed on the convex hull (see (e)). By the processing of 2), the convex polyhedron A ′ to be searched for the closest approach point
The number of planes of A ″ can be reduced (one plane for convex polyhedron A ′, two planes for convex polyhedron A ″), and the calculation load of the closest point search processing can be reduced.

(C) Flow of the closest approach point continuous search process FIG. 24 is a process flowchart of the closest approach point continuous search process between non-convex polyhedrons. Input data specifying the target non-convex polyhedron (initial input: environment model setting). Step 701 Next, the non-convex polyhedron is divided into convex polyhedrons, and each convex polyhedron P
Create directed graph type structure data of Hi. In addition, a convex hull is generated by merging, and directed graph type structure data of the convex hull is generated (step 702). When the above initialization process is completed, the first polyhedron of the present invention in the convex polyhedron is completed.
(Step 703). Next, it is checked whether or not they interfere (step 704). If they do, it is checked whether or not polygons having virtuality = 0 have interfered (step 705), and YES
If so, the processing is stopped without releasing either of the convex hulls, and the next instruction is awaited. However, if there is no interference between polygons of virtuality = 0, it is checked whether the polygon of virtuality = 1 (component of convex hull A) and the polygon of virtuality = 0 (component of convex hull B) have interfered. (Step 706).

If YES, the convex hull A having the polygon of virtuality = 1 is released (step 707). NO
Then, in other words, if the polygon having the virtuality = 1 (the component of the convex hull A) and the polygon having the virtuality = 1 (the component of the convex hull B) interfere with each other, the convex hull is decomposed into a convex polyhedron. Then, the convex hull with the smaller number of constituent convex polyhedrons is obtained (step 708), and the convex hull is released (step 707). Then, a surface convex polygon of a set DA including Edge (DA, PA) and Vertex (DA, PA) of the interference plane PA is retrieved from the directed graph type structure data of each convex polyhedron and passed to the processor (step 7).
09). After that, the processor calculates the surface polygon and convex hull B
In parallel, an interference check is performed by applying the first closest approach point search method (step 703).

On the other hand, if there is no interference between the objects in step 704, a recovery process is executed (step 710). In the recovery process, it is checked whether or not the convex hull whose merging has been canceled exists. If there is, it is checked whether or not it interferes with another object. Then, if the non-interference time of the convex hull whose merging has been canceled is equal to or longer than the set value, the convex hull is restored. However, if it interferes with another object or the non-interference time is not longer than the set value, the next step is executed without restoring the convex hull. Thereafter, the process returns to step 703 and the subsequent processes are repeated. Next, it is checked whether all parts of the convex hull are stationary (step 711). If not stationary, the process returns to step 703 and the subsequent steps are repeated. A convex hull is created (step 712), and the process returns to step 703 to repeat the subsequent processes.

(E) Second method for continuous search of the closest points between non-convex polyhedrons (a) Principle In the "continuous search for closest points", which continuously chase the closest points between a plurality of non-convex polyhedrons The merging process is performed on each of the non-convex polyhedrons to reduce and solve the continuity problem of the points of closest approach between the formal convex polyhedrons. At this time, the second closest approach point search method of the present invention is applied. That is, for each convex polyhedron obtained by merging, a triangulation (Triangulat
ion) and take a directed graph type data structure for the result of the triangulation, and keep the calculation load of the search for the closest approach point constant irrespective of the complexity of the target convex polyhedron. In merging, an index called virtuality is introduced.
In the surface polygon of the convex polyhedron obtained in the merging process, the virtuality is set to virtuality = 0 when the surface polygon matches the surface polygon of the original non-convex polyhedron, and virtuality = 1 when the surface polygon does not match.

When interference with a triangular polygon with virtuality = 1 occurs, merging is canceled (release of the convex hull), and the present invention is applied to the combination between the convex polyhedrons constituting the original non-convex polyhedron. The second closest point search method is applied. The rules for canceling merging are as follows. 1) If a triangular polygon with virtuality = 1 (a component of convex hull A) and a triangular polygon with virtuality = 0 (a component of convex hull B) interfere with each other, a convex hull A having a triangular polygon with virtuality = 1 is generated. To release. 2) If the triangular polygon with virtuality = 1 (component of convex hull A) and the triangular polygon with virtuality = 1 (component of convex hull B) interfere, the convex polyhedron when the convex hull is decomposed into a convex polyhedron Release the smaller number of convex hulls. 3) If the triangular polygons with virtuality = 0 interfere with each other, neither convex hull is released.

As shown in FIG. 25, if the convex hull A and the convex hull B interfere with each other (see (b)) and the convex hull A is released and a set DA (Decomposed A) of constituent convex polyhedrons appears (( c)).
The second closest point search method of the present invention in the convex polyhedron between the set DA and the convex hull B is applied. The algorithm in this case is as follows. 1) The interference triangle polygon of the convex hull A when the convex hull A is released is set to TA (Virtuality (TA) = 1). At this time, each side of the interference triangular polygon TA is composed of the element Edge (DA, PA) of the set DA and the side of virtuality = 1, and the lattice point of the interference triangular polygon TA is the element Vertex (DA, PA) of the set DA. It is composed of

2) The interference check between the set DA of the constituent convex polyhedron and the convex hull B is performed by Edge (DA, PA), Vertex (DA, PA) and convex hull B
This is performed by applying the second closest point search method of the present invention in a convex polyhedron. That is, Edge (DA, PA),
A triangular polygon of DA including Vertex (DA, PA) (see the hatched portion in (c)) is searched from the directed graph structure data of each convex polyhedron (A ′, A ″) constituting the non-convex polyhedron.
Next, an interference check is performed by applying the second closest approach point search method in parallel between the triangular polygon and the convex hull B obtained respectively (see (d)). 3) If the state escapes from the interference state with the triangular polygon of virtuality = 1, the convex hull released by the recovery processing is recovered, and the closest hull search processing is performed on the convex hull ((e)). By the processing of 2), the convex polyhedron A ′ to be searched for the closest approach point,
A ″ can reduce the number of triangular polygons (convex polyhedron A ′,
A ″, two each) can reduce the calculation load of the closest point search processing.

(B) Process for continuously searching for points of closest approach between non-convex polyhedrons FIG. 26 is a flowchart of a process for continuously searching for points of closest approach between non-convex polyhedrons. Input data specifying the target non-convex polyhedron (initial input: environment model setting). Step 801 Next, the non-convex polyhedron is divided into convex polyhedrons, and each convex polyhedron P
Triangulation is performed on Hi, and thereafter, directed graph type structure data of each convex polyhedron is created. In addition, a convex hull is generated by merging, and directed graph type structure data of the convex hull is generated (step 802).

When the above initialization processing is completed, a second closest point search processing (interference check) between the non-convex polyhedrons is executed (step 803). It is checked whether or not they interfere (step 804). If they do, it is checked whether or not triangular polygons with virtuality = 0 have interfered with each other (step 80).
5) If YES, stop processing without releasing either convex hull and wait for the next instruction. However, virtuality = 0
If the triangle polygons do not interfere with each other, it is checked whether or not the triangular polygon with the virtuality = 1 (the component of the convex hull A) and the triangular polygon with the virtuality = 0 (the component of the convex hull B) have interfered (step 806). If YES, the convex hull A having the triangular polygon with virtuality = 1 is released (step 807). If NO, in other words, if the triangular polygon with virtuality = 1 (component of convex hull A) and the triangular polygon with virtuality = 1 (component of convex hull B) interfere, the convex hull is converted into a convex polyhedron. Find the convex hull with the smaller number of constituent polyhedrons when decomposed (step 8)
08), the convex hull is released (step 807).

Next, the edge of the interference triangle polygon TA
Triangular polygons of a set DA including (DA, PA) and Vertex (DA, PA) are retrieved from the directed graph structure data of each convex polyhedron and passed to the processor (step 809). After that, the processor performs an interference check by applying the second closest approach point search method in parallel between the obtained triangular polygon and the convex hull B (step 803). On the other hand, if there is no interference between the objects in step 804, a recovery process is executed (step 810).

In the recovery process, it is checked whether or not a convex hull whose merging has been canceled exists. If there is, it is checked whether or not it interferes with another object. If not, the non-interference time is measured. Then, if the non-interference time of the convex hull whose merging has been canceled is equal to or longer than the set value, the convex hull is restored. However, if it interferes with another object or the non-interference time is not longer than the set value, the next step is executed without restoring the convex hull. Next, it is checked whether all parts of the convex hull are stationary (step 811). If not stationary, the process returns to step 803 and the subsequent processing is repeated. Create a convex hull (step 812),
03 and the subsequent processing is repeated.

(F) First Decomposition Process of Nonconvex Polyhedron into Convex Polyhedron (Preprocessing) (a) System Configuration To execute the search for the closest point between the nonconvex polyhedrons, the nonconvex polyhedron is converted into a convex polyhedron. Need to be disassembled. FIG. 27 is a system configuration diagram in a case where preprocessing for searching for the closest approach point is performed on the shape model on the graphic workstation.
GWS is a graphic workstation, CPU is a processor that executes pre-processing for searching for the closest approach point, processing for searching for the closest approach point, and other processing. MEM is a memory, and the shape data FD designed by a three-dimensional CAD system (not shown).
TPL, a preprocessing program ICP for searching for the closest approach point, 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. Operator O
The PR uses the operation unit OPS to input a command to the processor CPU to execute preprocessing on the shape model on the graphic workstation GWS. When the preprocessing command is input, the processor CPU
Preprocessing program I for searching for the closest approach point stored in M
Based on the CP, preprocessing (division processing of a polygon set of the non-convex polyhedron) is performed using the non-convex polyhedron shape data FDT. 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 Preprocessing for Searching for Nearest Point FIG. 28 is a schematic processing flow of preprocessing for searching for the closest point according to the present invention. The 3D CAD system creates a shape model (non-convex polyhedron) and creates a graphic work step GW
Input to S (steps 1001 and 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. 28, three real numbers following normal indicate the light reflection direction, and three real numbers following vertex indicate the vertex coordinate values. The procedure for outputting polygon data from a shape model in a three-dimensional CAD system is usually a three-dimensional CA
It is provided in the D system. Next, 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 based on the division and conquer method. That is, initial polygon data (polygon set of 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. 29 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, a polygonal subset of the first group and a polygonal 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. Definition P = {p1, p2, p3,...}: Initial polygon set DC (P) = {DP1 = [1p1, 1p2, 1p3,...]], DP2 = [2p1, 2p2, 2p3,. ],... ：: P divided polygon set NoP: Number of elements of P Algorithm (divided and conquer method) if (number of input polygons is 1, ie, NoP = 1) then DC (P) = P else DIVIDE: k = [Number of elements of P / 2] PL = {p1, p2, p3,..., Pk}: Polygon set equal to or less than k PH = {pk + 1, pk + 2, pk + 3,. Set RECUR: Costruct DC (PL) and DC (PH) recursively. MERGE: Merge DC (PL) and DC (PH) DC (P) = Merge (DC (PL), DC (PH)) endif As seen from the above algorithm In the divide and conquer law, the process of divide and govern is repeated recursively. The most important place where problem dependence exists in the divide-and-conquer method is the "merging" process, that is, the method of constructing the function Merge.

(D) Merge process in the divide-and-conquer method FIG. 30 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 represented by CLi,
As shown by CHj, it is composed of a set of polygons (polygons) constituting the element and a set of boundary edges (boundary edges) forming the boundary of the element. 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: 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 constituting 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 line, it is determined that Merge is possible.

3) Merge Order Merge of convex elements is performed in the following order. 3-1) It is determined whether or not the convex element CL1 can be merged with CHj (j = 1, 2,..., NPH). If CL1 can be merged with CHj, thereafter, CL1, DC (PH) is set as follows. CL1∪CHj → CL1 DC (PH) = ｛CH1, CH2,... CHj-1, C
Hj + 1...｝ 3-2) The same procedure is executed for CLi (i = 2, 3,..., NPL). 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) = ｛CL1, CL2,... CLPNPL, C
A merged convex element set DC (P) given by Hj ′, CHj ″... Is output (step 1113), where {CHj ′, CHj ″.
Is a DC (PH) convex element that does not merge with any CLi.

(E) Judgment of Unevenness Relationship between Polygons FIG. 31 is an explanatory diagram of the unevenness relationship determination processing between polygons. As shown in FIG. 31A, two polygons A and B sharing one boundary ridge BEG are assumed. The relative positional relationship between the polygons is either apart from each other or is in contact with each other via an edge as shown in FIG. etc)
Shall not exist. In FIG. 31 (a), vectors b,
c is a perpendicular vector dropped from the center of gravity p, q of polygon B and polygon A to boundary ridge line x1-x0 = a, respectively. Also, the vectors a, b, and c are unitized as e0, e1, and e2, respectively. nA and nB represent the outward normal vectors of polygon A and polygon B, respectively (the average of the light reflection directions at each grid point defining the polygon). At this time, b, c, e0, e1, and e2 are given by the following equations.

B = p−x0− (x1−x0) · (p−x0) (x1−x0) / |
x1-x0 | 2 is a vector dot product = p-x0-e0. (p-x0) e0 c = q-x0-e0. (q-x0) e0 e0 = a / | a | e1 = b / | b | e2 = c / | c | In order to determine the unevenness relationship between the polygons A and B, coordinate transformation is performed so that the vector b coincides with the X0 axis as shown in FIG. 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 nB, it can be said that the polygon A and the polygon B have a convex relationship. That is, 1) When (e0 × e1) · nB> 0 When [T · c] Z <0 and (e1 × e2) · nA> 0, 2) (e0 × e1) · nB In the case of ≦ 0 When [T · c] Z ≧ 0 and (e1 × e2) · nA ≦ 0, it can be said that polygon A and polygon B have a convex relationship. When dealing with actual CAD data, determination conditions are as follows in consideration of errors.

1) When (e0 × e1) · nB> 0 When [T · c] Z <ε and (e1 × e2) · nA> −ε, 2) (e0 × e1) When nB ≦ 0 [T · c] Z ≧ −ε and (e1 × e2) · nA ≦ ε, the polygon A and the 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 polygon subsets obtained by the divide-and-conquer method is
In fact, it is not always convex. The unevenness determination condition shown in FIG.
Local conditions. However, when the initial polygon set is divided under the conditions shown in FIG. 31, very good convexity is exhibited in many cases.

(G) Second Embodiment of Decomposition into Convex Polyhedron (Preprocessing) When performing convex decomposition by a basic algorithm based on the divide-and-conquer method, the number of convex elements after decomposition is not always the minimum. In the second embodiment, the number of convex elements is optimized (reduced 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. 32 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 then 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, a polygonal subset of the first group and a polygonal 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 a subset of polygons having a convex relationship with adjacent polygons in each group 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
While a convex polyhedron is generated using a polygon subset constituting (DC (P)), NDDC (P) and N
If DC (P) is not equal (eg, NDDC
(P) <NDC (P)), DC (DC (P)) → DC
(P) (step 1208).
The process after 04 is repeated. That is, a plurality of newly obtained polygon subsets DC (DC (P)) are repeatedly subjected to convex decomposition processing by the divide-and-conquer method. In the optimization method,
The convex decomposition basic algorithm is repeatedly applied to the output DC (P) until the number of convex elements no longer decreases.

(H) Third Embodiment of Decomposition into Convex Polyhedron (Preprocessing) In the method using the basic algorithm by the divide-and-conquer method,
There is a possibility that the number of divided convex elements in recognition of a hole or the like increases 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 with the negative object recognition method enables convex decomposition with a small number of convex elements.
FIG. 33 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, H
L 'is a hole portion whose normal direction is reversed, and BDY is an object without a hole (object without a hole). Objects with holes are BDY without holes
It is expressed by subtracting the hole portion whose normal direction is reversed from.

FIG. 34 is a flowchart of the convex decomposition processing of the third embodiment, and FIG. 35 is an explanatory diagram of the result of the convex decomposition. 3D C
An initial polygon set (polygon set of a non-convex polyhedron) P is input from an AD system or the like (step 1301), and then a polygon set PB in which all normal directions of the initial polygon set P are reversed is created (step 1302). After a while
The basic algorithm of convex decomposition is applied to the polygon set PB (step 1303). That is, the polygon set PB is divided into first and second groups, and a polygon subset having a convex relationship with adjacent polygons in each group is obtained. Then the first with a common border ridge
The polygon subsets of the group and the polygon subsets of the second group that have a convex relationship are merged to determine a plurality of new polygon subsets for each convex element.

Thereafter, a convex element set DC (PB) (see FIG. 35) having the plurality of polygon subsets as elements is output, and for each convex element of the convex element set DC (PB),
A convex element composed of two or more polygons is extracted, and all the polygon sets constituting the convex element are represented by P2 (D
C (PB)). That is, polygons constituting negative object convex elements such as holes are collected and set as P2 (DC (PB)) (step 1304). Next, a difference set between the initial polygon sets P and P2 (DC (PB)) is obtained, and a polygon set P-P2 (DC (PB)) constituting the regular object is obtained (step 13).
05). When the polygon set (difference set) constituting the regular object is obtained, the basic algorithm of convex decomposition by the divide and conquer method is applied to the difference set P-P2 (DC (PB)) (step 13).
06). In other words, the difference set P-P2 (DC (PB)) is
, 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 the polygon subset of the second group having a common boundary ridge line in a convex relationship. Thereafter, a convex element set DC (P-P2 (DC (PB))) having the plurality of polygon subsets as elements is output (step 1307, FIG. 35) to recognize a regular object. Finally, DC (P-P2 (DC (PB))) is a convex element of a positive object, D
C (PB) is output as a convex element of the negative object (step 1308). Thereafter, a convex polyhedron is generated using the polygon subset of each convex element.

(I) Fourth Embodiment of Decomposition into Convex Polyhedron (Pre-processing) The third embodiment is performed in the same manner as the first embodiment of the convex decomposition in which the number of convex elements is reduced by performing an optimization method. An optimization method can be applied to the example to reduce the number of convex elements. FIG. 36 is a flowchart of the convex decomposition processing in such a case, which 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'.

(J) Fifth Embodiment of Decomposition into Convex Polyhedron (Preprocessing) (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 brute force combinations of polygon sides constituting 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 formed by the boundary ridge line of the convex element CLi and the convex object formed by the boundary ridge line of the convex element CHj And interfere. Therefore, before executing a process for obtaining a common boundary ridge line of 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 O (N) interference check method. It is checked whether there is any interference between the ridge and the convex object. Then, 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. 37 is another schematic processing flow of the interference check pre-processing of the fifth embodiment, and the same reference numerals are assigned to the same parts as those of the first embodiment of FIG. are doing. The difference from the first embodiment is that in step 1003 ', instead of the convex decomposition basic algorithm based on the divide-and-conquer method, a basic convex decomposition algorithm based on the divide-and-conquer method incorporating an interference check (a fast convex decomposition basic algorithm) is applied. It is a point.

FIG. 38 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, a polygonal subset of the first group and a polygonal subset of the second group having a common boundary edge 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 problem dependence exists in the divide-and-conquer method is the "merging" process, that is, the method of constructing 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. 39 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 = ｛pCL11, pCL12, pCL13,
・ ・ PNCLP1｝ boundary edges = [bCL11, bCL1
2, bCL13,... BNCLB1} DC (PH) = {CH1, CH2,... CHi,.
2, ... NDC (PH) CLi ｛polygons = ｛pCH11, pCH12, pCH13,
・ ・ PNCHP1｝ boundary edges = [bCH11, bCH1
2, bCH13,..., BNCB1} Each element of the convex element set DC (PL), DC (PH) is composed of polygon subsets (polygons) and a set of boundary edges forming the boundaries of the elements (boundary edges). You.

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 ridge BedgeCL of convex elements CLi and CHj
An interference check is performed between i and BedgeCHj. If there is no interference, it is determined that Merge is 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 constituting 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) It is determined whether or not the convex element CL1 can be merged with CHj (j = 1, 2,..., NPH). If CL1 can be merged with CHj, thereafter, CL1, DC (PH) is set as follows. CL1∪CHj → CL1 DC (PH) = ｛CH1, CH2,... CHj-1, C
Hj + 1...｝ 3-2) The same procedure is executed for CLi (i = 2, 3,..., NPL). 4) Configuration of merged convex element set DC (P) By the process of 3) above, merged convex element set DC (P) = Me
rge (DC (PL), DC (PH)) is executed and DC
(P) = ｛CL1, CL2,... CLPNPL, CH
j ′, CHj ″... {}
(P) is output (step 1113 '). Where ｛C
Hj ', CHj "...} Are DC (PH) convex elements that do not merge with any CLi.

(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. 40 is a schematic processing flow of the interference check algorithm. Convex element CLi,
An interference check algorithm is applied between convex objects formed by the boundary edges BedgeCLi and BedgeCHj of CHj (step 1401). The distance dist (BedgeCLi, BedgeCHj) between the closest points of the boundary edges BedgeCLi, BedgeCHj is obtained and output by applying the interference check algorithm.
(Step 1402). If you find the distance between the closest points,
The distance dist (BedgeCLi, BedgeCHj) is compared with the value of ε. If dist (BedgeCLi, BedgeCHj) ≦ ε, it is determined that interference occurs, and dist (BedgeCLi, BedgeCHj)>
In the case of ε, 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 Checking Method (Gilbert Method) Boundary ridges BedgeCLi, BedgeC of convex elements CLi, CHj
The search between the closest points between the convex objects constituted by Hj and the distance dist (BedgeCLi, BedgeCHj) are performed by the aforementioned Gilbert.
Determined by the law. The initial grid point (initial value) V0 of the Gilbert method is generally arbitrary, but it is efficient to start from the grid point of each object in the direction of the center of gravity difference. When finding the point of closest approach using the Gilbert method, the following inequality holds:
(See FIG. 41). rk = −hk (−νk) / | νk | ≦ | ν (K) | ≦ | νk | (16) Therefore, for a certain k, if rk> 0, it can be said that there is no interference between the biconvex objects.

(G) Merge Possibility Judgment Processing Based on Gibert Method FIG. 42 is a flowchart of Merge possibility judgment processing based on the Gilbert method. Boundary edge BedgeCL of convex elements CLi, CHj
i, BedgeCHj
Apply the rt method to calculate rk in equation (13) (step 1)
411). Then, it is determined whether rk> 0 (step 141).
2) If rk> 0, there is no interference, so it is determined that merging is not possible (step 1413). However, rk ≦ 0
In the case of, because there is interference, there is Merge interference,
Merge availability / 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 select an arbitrary vertex BedgeCLi0 and BedgeCHji0 from the vertex set BedgeCLi and BedgeCHj on the boundary ridge line as the initial lattice point V0 of the Gilbert method, and construct V0 = BedgeCLi0−BedgeCHji0 (17). Then, using this V0, r = -hk (-V0) =-hk1 (-V0) -hk2 (V0) (18) is calculated. If r> 0, BedgeCLi, Bedge
There is no interference between CHj and the convex elements CLi and CHj are Merge
It is determined that there is no possibility of performing this.

FIG. 43 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 BedgeCLi and BedgeCHj of (15)
The r of the equation is calculated (step 1411 '). Then r
> 0 (step 1412 ′). If r> 0, there is no interference, so it is determined that merge is impossible (step 1).
413 '). However, in the case of r ≦ 0, it is determined that there is Merge interference because of interference, and the above-mentioned Merge possibility condition 2
-Determine whether Merge is possible / impossible from condition 4 (step 1
414 ').

(K) Modification of Convex Decomposition (a) Modification 1 The convex decomposition method of the fifth embodiment described above may be configured to perform optimization processing to reduce the number of convex elements. FIG. 44 shows a processing flow in this case. In FIG. 44, the difference from the process of the second embodiment (see FIG. 32) is that
02 ′, 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. FIG. 45 shows a processing flow in this case. In FIG. 45, the difference 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.

(L) Preprocessing for Searching for Nearest Point (Formation of Linear List of Proximity Points) In the above description, directed graph type structural data is generated from polygon data by preprocessing, and between the convex polyhedrons or This is the case where the closest point search processing between non-convex polyhedrons is performed. Structural data different from the directed graph structure data, that is, a near-point linear list is created by preprocessing, and the use of the list can speed up the continuous search for the closest approach point. The near-point linear list is such that vertices of each polygon constituting a shape model (CG model) are linked in a first direction (next direction), and a vertex group connected to each vertex via a polygon side is defined in a second direction (b).
This is a list provided with a data structure linked to the vertex in the (rank direction). By sequentially tracing from the top of the list, it is possible to pick up all the proximity points connected to the vertex.

(A) Example of Proximity Point Linear List FIG. 46 shows an example of a rectangular parallelepiped proximity point linear list. As shown in the figure, the proximity point linear list has two directions: a next direction in which vertices are sequentially connected, and a branch direction in which proximity points connected to each vertex via polygon sides are arranged. The top of the branch direction contains the vertex itself. (b) Method of Constructing Proximity Point Linear List FIG. 47 is a flowchart of a process of creating a proximity point linear list.
As shown in FIG. 48, the target object is composed of a set of triangular polygons, and each triangular polygon is represented by three vertex coordinate values following vertex and light reflection direction data at three vertices following normal. You.

The three-dimensional CAD system creates a shape model and outputs a polygon data file (step 20).
01, 2002). 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 based on an interference check built-in division and conquer method. That is, the initial polygon data is divided into sets of subsets for each convex element and output (steps 2003 and 2004). Thereafter, a near-point linear list is generated for each subset, that is, for each convex polyhedron using a near-point linear list construction algorithm, and is expanded in a memory (steps 2005 and 2006). Next, the closest point search processing (interference check processing) is executed using the close point linear list, and the close point linear list is stored in the external storage medium (step 2007). Since then
If the proximity point linear list is required, the list is read from an external recording medium and developed in a memory without newly creating the list (step 2008).

(C) Proximity point linear list construction algorithm FIG. 49 is an explanatory diagram of polygon data for each convex element of a target object.
FIG. 50 is an explanatory diagram of a neighboring point linear list construction algorithm. Assuming that the target object is constituted by a set of triangular polygons, the near point linear list is constituted according to the following flow. 1) Polygon data for each convex element is prepared by the convex decomposition basic algorithm (see FIG. 49). 2) For each polygon data (pi, qi, ri), connect each vertex to the list L. The next direction is defined as a linear list direction with respect to the vertices, and the branch direction is defined as a direction of a proximity point of each vertex. The head element of the list L is the first vertex of the first polygon, and has a data structure shown in FIG. Specifically, a list is created as follows. 2-1) Assign top element top of list L. That is,
Assign the first vertex of the first polygon as top.

2-2) For the polygon (pi, qi, ri),
Repeat the following assignment. 1) If if (Lj ≠ pi for all j), assign a new element pi to the end in the next direction (see FIG. 50 (b)). Then, for the branch direction of the vertex Lj + 1, pi and q
i and ri are assigned (see FIG. 50 (c)). 2) If if (Lj = pi for a certain j), qi and ri are assigned to the branch direction of Lj. If there is already the same vertex as qi and ri in the branch direction, no assignment is made (see FIG. 50 (d)). 3) The above processes 1) and 2) are performed on the vertex qi. However, branch candidates other than qi for vertex qi are pi and ri. 4) The above processes 1) and 2) are executed for the vertex ri. However, branch candidates other than ri for the vertex ri are pi and qi. 2-3) For all polygon sets ∪i (pi, qi, ri),
Repeat the process of 2-2).

(D) Example of Creating Proximate Point Linear List FIGS. 51 and 52 are explanatory diagrams of an example of creating a proximal point linear list. Polygon data for each convex element is prepared by the basic convex decomposition algorithm (step 2011). Since then,
The polygon is incorporated into the list (step 2012), and the second polygon is incorporated into the list L (step 2).
013). That is, in step 2012, first, the first vertex V1 of the first polygon is assigned as top. That is, top = L1 = V1 (2012a). Then, bran for vertex V1
All vertices V1, V2, V3 of the first polygon are allocated in the ch direction (step 2012b). Then, the second vertex V
2 are allocated in the next direction (step 2012c), and after the allocation, all the vertices V2, V3, and V1 of the first polygon are allocated in the branch direction with respect to the vertex V2 (step 2012).
d). Thereafter, the third vertex V3 is similarly allocated in the next direction.
(Step 2012e) After allocation, b for vertex V3
All vertices V3, V1, and V2 of the first polygon are allocated in the ranch direction (step 2012f).

In step 2013, the first vertex V1 of the second polygon is assigned. In this case, since the vertex V1 is already allocated in the next direction, the branch of the vertex V1 is
Vertices V1, V3, and V4 are allocated in the ch direction. But,
Since the vertices V1 and V3 have already been allocated, the vertex V
Only 4 is assigned (step 2013a). Then
The second vertex V3 is allocated in the next direction. In this case, next
Since the vertex V3 has already been allocated in the direction,
The vertices V3, V4, and V1 are allocated in the branch direction of No. 3.
However, since the vertices V3 and V1 have already been allocated, only the vertex V4 is allocated (step 2013b).
Thereafter, the third vertex V4 is allocated in the next direction (step 2013c). Next, the vertices V4, V1, and V3 are allocated in the branch direction of the vertex V4 (step 2013).
d). In the above, the polygon has been described as a triangular polygon, but is not limited to a triangular polygon, and may be any polygonal polygon. The computational load for creating a near-point linear list from N vertices is O (N2).

(M) Preprocessing for Searching for Nearest Point (Creation of Proximity Point Multi-Tree List) The computational load for creating a linear list of proximity points is O (N2) for N vertices, which is large. Therefore, a list (proximity point multi-tree list) of another data structure that can be used for continuous search for the closest point is created, and the continuous search for the closest point is speeded up by using the list. The proximity point multitree list is an array list of vertices as follows. That is, the reference vertex is determined, the first next direction (xright) larger than the X coordinate value of the reference vertex, and the second direction smaller than the X coordinate value.
Next direction (xleft), third next direction (yright) larger than Y coordinate value, fourth next direction smaller than Y coordinate value
(yleft), the fifth next direction (zrigh
t), a sixth next direction (zleft) smaller than the Z coordinate value is determined. Then, each axis coordinate value of the reference vertex is compared with each axis coordinate value of a vertex connected to the reference vertex by a polygon side (referred to as a target vertex), and a next direction for linking the target vertex is determined according to the magnitude. At the same time, the target vertices are linked in the next direction in the order closer to the reference vertex. When linking the target vertex in the next direction, if the coordinate value of the other vertex already linked in the next direction is equal to the coordinate value of the target vertex, the axis coordinates of the other vertex and the target vertex are changed. Compare. Then, a next direction corresponding to the magnitude is obtained, and the target vertex is linked to the other vertex in the next direction. Also, a branch direction is determined for each vertex, and all vertices connected to the vertex by polygon sides are arranged in the direction. The one created as described above is the proximity point multi-tree list.

(A) Example of Proximity Point Multi-Tree List FIG. 53 shows an example of a rectangular parallel-tree multi-point tree list. As shown in the drawing, each vertex has six link directions xright, xleft, yright, yleft, zright, and zleft corresponding to the magnitudes of the x, y, and z axes, and one branch. Has directions. Vertex
In the branch direction, all vertices connected to the vertices by polygon sides are arranged, and the vertices themselves are arranged at the head thereof.

(B) Method of Constructing Proximity Point Multi-Tree List FIG. 54 is a flowchart of a process of creating a proximity point multi-tree list. The three-dimensional CAD system creates a shape model and outputs a polygon data file (steps 2101, 2
102). 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 based on an interference check built-in division and conquer method. That is, the initial polygon data is divided into sets of subsets for each convex element and output (steps 2103 and 2104). Thereafter, a near-point multitree list is generated for each subset, that is, for each convex polyhedron by using a near-point multitree list construction algorithm (step 2105). Next, the near-point multitree tree conversion algorithm is used to convert the near-point multitree tree list into a near-point linear list and expand it in the memory (steps 2106 and 21).
07). Thereafter, the closest point search processing (interference check processing) is executed using the close point linear list, and the close point linear list is stored in the external storage medium (step 21).
08). Thereafter, when the proximity point linear list is required,
Instead of creating a new one, it is read from the external recording medium and expanded in the memory (step 2109).

(C) Proximity point multitree list construction algorithm Assuming that the target object is composed of a set of triangular polygons, the proximity point multitree list is constructed according to the following flow. 1) Polygon data for each convex element is prepared by the convex decomposition basic algorithm (see FIG. 49). 2) For each polygon data (pi, qi, ri), connect each vertex to the multi-tree list ML. Maybe tree list M
In L, xright, xleft, yright, yleft, zright,
x, y, z as viewed from the vertex where zleft is focused
It is the direction of the axis. Also, each vertex is defined as
Has a branch direction. Specifically, the proximity point multi-tree list ML is constructed according to the following procedure (see FIG. 53).

2-1) The top element top of the ML is allocated. to
As p, assign the first vertex of the first polygon. 2-2) The following assignment is repeated for polygons (pi, qi, ri). (1) The vertices pi are compared lexicographically in the order of the magnitude of the x coordinate value, the magnitude of the y coordinate value, and the magnitude of the z coordinate value as viewed from the top element top of the ML, and are assigned. That is, first, the vertex p
When the x-coordinate value of i is larger than the x-coordinate value of top, the x-coordinate value of another element arranged in the xright direction is compared with the x-coordinate value of the vertex pi when viewed from top. Are arranged in ascending order. The x coordinate value of vertex pi is to
When it is smaller than the x coordinate value of p, the same arrangement is performed in the xleft direction when viewed from the top. If there is a placed vertex having an x-coordinate value that matches the x-coordinate value of the vertex pi, the y-coordinate value is compared, and the vertices are arranged in ascending order in the y-coordinate direction when viewed from the placed vertex. I do. If there is an already-arranged vertex having the same y-coordinate value, a similar ascending arrangement is performed on the z-coordinate value. If there is a vertex at which all the coordinate values of x, y and z match, the vertex pi is regarded as the same. (2) For the newly allocated vertex pi, the branc of this vertex pi
Assign pi and qi, ri in the h direction. If the vertex pi already has a branch element, it is compared with each branch element to avoid assigning the same point.

(3) The above processes (1) and (2) are performed on the vertex qi. However, a branch other than qi for vertex qi
Candidates are pi and ri. (4) The above processes (1) and (2) are performed on the vertex ri.
However, branch candidates other than ri for vertex ri are pi,
qi. 2-3) For all polygon sets ∪i (pi, qi, ri),
Repeat the process of 2-2). In the above, the polygon has been described as a triangular polygon, but is not limited to a triangular polygon, and may be any polygonal polygon. The computational load for creating a near-point multitree list from N vertices is O (NlogN)
It is.

(D) Proximity point multi-tree list conversion algorithm In the interference check between convex polyhedrons (closest point search processing), a calculation is performed to obtain a vector inner product with each vertex of the convex polyhedron and detect the maximum value. Repeat. At this time,
If each vertex is in the form of a proximity point multitree list, a large number of complicated determination functions will be involved when sequentially following each vertex. Therefore, once the proximity point of each vertex is formed in the form of the proximity point multi-tree list, the calculation amount can be reduced by converting the multi-tree list into a linear list.
To convert a multi-tree list into a linear list, for example, use the following recursive function vertex * MultiToLinear ().

Vertex * MultiToLinear () [vertex * V; v = this; // this indicates the pointer of the current vertex if (next = 0) [if (xleft! = 0) [// allocates xleft to next next = xleft; v = xleft → MultiToLinear (); // act recursively in xleft direction] if (xright! = 0) [// same for xright, yleft, yright, zleft, zright v → next = xright; v = xright → MultiToLinear ();] if (yleft! = 0) [v → next = yleft; v = yleft → MultiToLinear ();] if (yright! = 0) [v → next = yright; v = yright → MultiToLinear ();] if (zleft! = 0) [v → next = zleft; v = zleft → MultiToLinear ();] if (zright! = 0) [v → next = zright; v = zright → MultiToLinear [] return V;] When the above function is applied to the top element top of the multi-tree list ML (top → MultiToLinear ()), the multi-tree list ML is converted into a linear list L. The calculation time of the neighboring point multitree list conversion algorithm is O (N), where N is the total number of vertices.
It is. Therefore, the total calculation time for generating the proximity point linear list L from the polygon data through the proximity point multi-tree list construction algorithm is O (NlogN).

(N) Preprocessing for Searching for Nearest Point (Dumping and Loading of Near-Point Linear List) The near-point linear list information required for the closest-point search processing, that is, the interference check processing, is all expanded on the memory. Must be kept. If the dump file (dump
file) to the memory, the same calculation time as constructing the neighboring point multitree list (O for the total number of vertices N)
If (NlogN)) is required, there is no point in creating a dump file. Therefore, in the present invention, the format of the dump file is determined so that the loading time from the dump file becomes O (N). (a) Format of Dump File The format of the dump file is as shown in FIG. In this file format, essential items for high-speed loading are as follows. 1) Each convex element is separated, 2) There is an item of the total number of vertices (count) constituting the convex element, 3) Each vertex is numbered, 4) Each vertex , The number of neighboring points of the vertex (bcount)
5) There must be an item that defines the coordinates of each vertex.

(B) Loading Method from Dump File 1) The total number of vertices (count) constituting the convex element is read, and a count-dimensional array for storing each vertex is created. 2) Each vertex of the convex element is stored in the array, and each vertex is connected in the next direction to form a linear list. For example, Ve
When the array containing rtex is V [Ni], V [0], V
.. Are sequentially connected in the next direction to form a linear list. 3) Apply the processing of 1) and 2) to each convex element.

4) For each vertex of each convex element, a list of adjacent points is set in the branch direction based on the adjacent point number of the branch (designating the position in the array). For example, when the array that stores the vertices is V [Ni], the number of the branch of the vertex V [0] is
If (0,9,1,7,8), V in the branch direction of VertexV [0]
[0], V [9], V [1], V [7], V [8] are linked to a linear list. 5) Apply the processing of 4) to each convex element. In the above loading method, the same file is read twice (1), 2), 3) for the first time and 4), 5) for the second time. In most cases, the number of branches at each vertex is suppressed to several tens or less, so that the total loading time is O
(N). As shown in FIG. 55, a dump file divided for each convex element is called an L file. (c) Dump file for convex hull A dump file similar to that in FIG. 55 is defined for the smallest convex polyhedron (convex hull) wrapping a non-convex polyhedron. In this case, the number of convex elements is one, and vertex consists of all vertices constituting the non-convex polyhedron. A file in the format shown in FIG. 55 for the convex hull is called an HL file.

(O) Interference Check Sub-Algorithm (Preliminary Check Using Envelope Sphere) For an arbitrary non-convex polyhedron, a sphere that envelopes it is generated in preprocessing. At this time, before the interference check between the non-convex polyhedrons is started, the interference check is performed between the envelope spheres to increase the speed. (a) Construction method of envelope sphere A non-convex polyhedron is represented by a set of triangular polygons.
∪i (pi, qi, ri). The suffix i is a subscript for identifying each polygon. The coordinate values of pi, qi, ri are represented by pi = (pix, piy, piz), qi = (qix, qiy,
qiz), ri = (rix, riy, riz). At this time,
The max and min points of the convex hull are obtained as follows. max = (MAXi (pix, qix, rix), MAXi (piy, qiy, riy), MAXi (pi
z, qiz, riz)) min = (MINi (pix, qix, rix), MINi (piy, qiy, riy), MINi (pi
z, qiz, riz)) The envelope sphere is defined based on the following formula. Radius R = | max-min | / 2 center Pc = (max + min) / 2

(B) Envelope sphere for convex element For each convex element, a sphere that envelopes each convex element is defined. The calculation method is the same as in (a). Where m
The suffix i when defining ax, min means a polygon set of each convex element. (c) Preliminary Check Algorithm Using Envelope Sphere FIG. 56 is a processing flow of a prior check using an envelope sphere. Envelope sphere radii RA, RB of each non-convex polyhedron A, B, envelope sphere center P
CA and PCB are obtained by the above-described method (step 2201,
2202), the center-to-center distance r of each envelope sphere is determined by the following equation: r = | PCA-PCB |, and it is checked whether r ≦ (RA + RB) (step 2203). If r> (RA + RB), it is determined that there is no interference (step 2204). r ≦ (RA + RB)
If so, it is determined that they interfere with each other, and thereafter interference check between non-convex polyhedrons is performed (step 2205).

(P) Interference Check Sub-Algorithm (Continuous Search in Convex Polyhedron Interference Check) Extract vertices that are closest to the closest approach point obtained from the nearest point linear list, and use the Gilbert's interference check method for these vertices. Is applied to search for the closest approach point after a predetermined time. By doing so, the time required for the interference check can be suppressed to a certain number or less that hardly depends on the number of polygons representing the convex polyhedron. (a) Gilbert method The distance ν (K) between the closest points between the convex polyhedrons K1 and K2 is g
For νK where K (νK) = 0, using equation (12) ′, ν (K) = νk = ν (coVk) = Σλiiy (i （Is) = Σλix1i (i∈IK1Sk) −Σλix2i (i∈) IK2Sk) (19) where x1i: a vertex of K1 and x2i: a vertex of K2.

(B) Intuitive Understanding of the Gilbert Method FIG. 57 is an explanatory diagram for intuitively understanding the closest approach point searching method by the Gilbert method. Each process is briefly described as follows. 1) Setting of vector η The geometric centroids of two objects are connected to each other and set to ν0 (FIG. 57).
Figure (a)). 2) Calculation of the following inner product hK1 (−ν0) = max [−x1i · ν0: i = 1,... M1] (20) hK2 (−ν0) = max [−x2i · ν0: i = 1,. [M2] (21) to select the two points p0 and q0 that are closest to each other in the direction of the vector ν0 (FIG. 57 (a)). 3) Update of ν1 The two points p0 and q0 are connected to form ν1 (FIG. 57 (b)). 4) Inner product calculation The same inner product calculation as in 2) is performed on ν1 and two new points p
1 and q1 are selected (FIG. 57 (b)). 5) The inner product calculation and the update of ν1 are repeated to obtain the final closest approach point vector νfinal (FIG. 57 (c)). As can be seen from the above process, the main computational load in the Gilbert method occurs during the dot product calculation. Therefore, Gilber
The calculation time of the closest approach point search in the t method is O (m1 + m2).

(C) Continuous interference check in convex polyhedron The computation load in the Gilbert method is determined by the support functions hK1, h
It occurs in the process of calculating the inner product of K2. Therefore, in order to reduce the number of times of calculating the inner product, a method of efficiently finding a proximity point of the closest approach vector ν (K) will be considered. Convex polyhedron K1,
The closest approach points νK1 and νK2 of K2 are given by the following equations from equation (19). νK1 = Σλix1i (i∈IK1Sk) (22) νK2 = Σλix2i (i∈IK2Sk) (23) In the case of continuously searching for the closest approach point, the closest approach point after a predetermined time is given by formulas (22) and (23). It exists near the given νK1 and νK2. Therefore, the vertices for calculating the support functions hK1 and hK2 are vertices x1i,
x2i.

FIG. 58 is a flowchart of a continuous interference check algorithm for a convex polyhedron. First, the geometric centers GK1 and GK2 of the two convex polyhedrons are obtained, and the vector ν0 = GK1-GK2 is obtained (step 2301). Then, an interference check algorithm by the Gilbert method is executed using ν0 as an initial value, and νK1 and νK2 given by the equations (22) and (23) are obtained.
(Step 2302). Then, ν0 = νK1-νK
As 2, an interference check algorithm by the Gilbert method is executed (step 2303). However, in the calculation of the support function hK (−ν1) = hK1 (−ν1) + hK2 (ν1), hK1 (−ν1) and hK2 (ν1) are calculated based on the following equations. hK1 (−ν1) = max [−x1i · ν1: p = number of sets of adjacent points of x1i given by equation (22)] hK2 (−ν1) = max [−x2i · ν1: p = p22 The number of the set of proximity points of given x1i] Then, the closest point is calculated by the equations (22) and (23), and thereafter g
The process from step 2303 is repeated until K (νK) = 0. The number of points near the vertices x1i and x2i in FIG. 58 can be suppressed to several tens or less in most CG models (shape models). Therefore, the calculation load of the continuous interference check algorithm is constant regardless of the number of polygons in the CG model.

(Q) Interference Check Sub-Algorithm (Dynamic Construction / Release of Convex Hull) For a non-convex polyhedron, a convex hull is defined as the smallest convex polyhedron that envelopes it. When the distance between the non-convex polyhedrons is sufficiently large, an interference check between the convex hulls is performed. When the convex hulls start to interfere with each other, the process automatically shifts to an interference check between the convex elements constituting the non-convex polyhedron. . When the distance between the non-convex polyhedrons is increased again, the convex hull is recovered, and the process returns to the check for interference between convex hulls. (a) Basic Concept of Dynamic Configuration / Release of Convex Hull FIGS. 59 and 60 are explanatory diagrams showing the basic concept of configuration / release of a convex hull. In FIG. 59, A and B are the first,
The second non-convex polyhedron, CA1 and CA2, are convex polyhedrons constituting the non-convex polyhedron A, and CB1, CB2 are convex polyhedrons constituting the non-convex polyhedron B. 1) If the non-convex polyhedrons A and B are sufficiently separated, an interference check between the convex hulls A 'and B' is performed (see FIG. 60 (a)).

2) When convex hulls A 'and B' start to interfere with each other
(See FIG. 60 (b)), one convex hull A 'is released, and the convex element C
An interference check between A1 and CA2 and the convex hull B 'is performed, and if there is interference, the convex element CA1 is taken out (see FIG. 60 (c)). 3) Next, the positions of the convex element and the convex hull are exchanged, the other convex hull B 'is released, and the convex element CB of the released convex hull is released.
1, CB2 and the convex hull A 'are checked for interference, and the interfering convex element CB1 is extracted (see FIG. 60 (d)). 4) Finally, all combinations of the extracted convex elements (Fig. 6
At 0, interference check is performed for CA1, CB1),
The distance that minimizes the distance is calculated. (FIG. 60
(e)). In 2), for example, as shown in FIG. 61 (a), when there is no interference between the convex elements CA1, CA2 and the convex hull B ', the closest approach between the convex elements CA1, CA2 and the convex hull B' A vector is obtained, and two end points p and q giving the vector are set as points of closest approach. In addition, as shown in FIG.
1, CB2 and the convex hull A 'are interchanged, and if there is no interference between the convex hull and the convex hull, the closest approach vector between the convex elements CB1 and CB2 and the convex hull A' is obtained. The two end points p 'and q' giving the vector are the closest points.

FIG. 62 is a processing flow of a dynamic construction / cancellation algorithm of a convex hull. Convex hull A 'of non-convex polyhedrons A and B,
Interference check processing (closest search processing) is performed between B '
The distance r (A ', B') between the closest points is obtained. Then
It is determined whether r (A ′, B ′) and εCH are large or small (step 2401). εCH is a user-defined minute constant. r
When (A ′, B ′)> εCH, the convex hulls A ′ and B ′ do not interfere with each other, so the closest point between the convex hulls A ′ and B ′ is the closest point between the non-convex polyhedrons A and B. Output (step 240
2). Thereafter, the above processing is repeated while maintaining the convex hull.
On the other hand, when r (A ′, B ′) ≦ εCH, one convex hull, for example, the convex hull A ′ is released because the convex hulls interfere with each other. Let the union of the convex elements CAi of the non-convex polyhedron A be ∪iCAi
Is expressed as Next, a subset 凸 iCCAi of convex elements whose distance r (CAi, B ′) between the convex hull B ′ and each convex element CAi is equal to or smaller than εCCH is obtained (step 2403). εCC
H is a user-defined minute constant. Thereafter, it is checked whether the number of convex elements constituting the subset ∪iCCAi is 0 (step 2404). ∪If iCCAi = 0, the minimum distance MINir (CA) of r (CAi, B ′)
i, B '), and finds the convex element CAk.
The closest point between k and the convex hull B 'is determined, and the closest point is output as the closest point between the non-convex polyhedrons A and B (step 24).
05).

However, if ∪iCCAi> 0, the other convex hull B ′ is released. Convex element CBj of non-convex polyhedron B
Is expressed as ∪jCBj. Next, the distance r (CBj, A ') between the convex hull A' and each convex element CBj is εCCH
The following subset of convex elements ∪jCCBj is obtained (step 2406). Thereafter, it is checked whether the number of convex elements constituting the subset ∪jCCBj is 0 (step 24).
07). ∪ If jCCBj = 0, r (CBj,
A ′), a convex element CBk that gives the minimum distance MINjr (CBj, A ′) is obtained, the closest point between the convex element CBk and the convex hull A ′ is obtained, and the closest point is determined as a non-convex polyhedron A, B It is output as the point of closest approach (step 2408). But,
If ∪jCCBj> 0, the minimum distance MINi, j R (CCAi,
CCBj) to obtain convex elements CCAp and CCBq
The closest point between them is determined and output as the closest point between the non-convex polyhedrons A and B (step 2409). Thereafter, the process returns to the beginning and the subsequent processes are repeated.

(R) Interference Check Sub-Algorithm (Dynamic Construction / Canceling of Convex Hull and Convex Polyhedron Continuous Interference Check) For a non-convex polyhedron, a convex hull is defined as the smallest convex polyhedron that envelopes it. If the distance between the non-convex polyhedrons is sufficiently large, a continuous interference check between the convex hulls is performed. If the convex hulls start to interfere with each other, the system automatically shifts to the interference check between the convex elements constituting the non-convex polyhedron I do. When the distance between the non-convex polyhedrons is increased again, the convex hull is recovered, and the process returns to the continuous interference check between convex hulls. FIG. 63 is a processing flow of an algorithm for dynamically constructing / releasing a convex hull and checking for a convex polyhedron continuous interference, and FIGS. 64 to 66 are explanatory diagrams thereof. An interference check process (closest search process) is performed between the convex hulls A 'and B' of the non-convex polyhedrons A and B, and a distance r (A ', B') between the closest points.
Ask for. Then, the magnitudes of r (A ', B') and εCH are determined. Also, the flag contflgA '= 1 is set (step 2501). When r (A ', B')> εCH, the convex hulls A 'and B' do not interfere with each other, so the closest point between the convex hulls A 'and B' is the closest point between the non-convex polyhedrons A and B. Is output (step 2502). Thereafter, the above processing is repeated while maintaining the convex hull.

FIG. 64 specifically shows the process of steps 2501 and 2502. As shown in FIG. 64, in the interference check between convex hulls, the first support function h
Is calculated based on the inner product calculation for all points, but is calculated based on the algorithm of the continuous interference check from the next time onward. That is, the inner product calculation is limited to the closest point to the closest point. In the continuous interference check, it is necessary to hold the information of the closest point of last time, but this information is held as one attribute of the convex hulls A ′ and B ′. In the process of step 2502, the flag of contflg A '= 1 is set, and the interference check between (A', B ') becomes a continuous type. In step 2501, r (A ′, B ′) ≦ ε
In the case of CH, the convex hulls interfere with each other,
For example, the convex hull A 'is released. Convex element CA of non-convex polyhedron A
The union of i is expressed as ∪iCAi. Then, the convex hull B '
And the distance r (CAi, B ') between each convex element CAi is εCC
A subset 凸 iCCAi of convex elements equal to or less than H is obtained. or,
The flag contflgCCA1 = 1 (step 250)
3).

Thereafter, it is checked whether the number of convex elements constituting the subset ∪iCCAi is 0 (step 250).
4). ∪ If iCCAi = 0, r (CAi,
B ′), a convex element CAk that gives the minimum distance MINir (CAi, B ′) is determined, and the closest point between the convex element CAk and the convex hull B ′ is determined. Then, the closest point is output as the closest point between the non-convex polyhedrons A and B (step 250).
5). r (CAi, B ') is obtained by a continuous interference check.

FIG. 65A shows steps 2503 to 250
FIG. 5 is a specific explanatory diagram of FIG. The previous closest point information in the continuous interference check is the convex element CAi of the non-convex polyhedron A.
Is retained as an attribute. In step 2503, co
The flag of ntflgCCA1 = 1 is set, and step 2505 is executed.
The interference check between (CAi, B ') is a continuous type. In step 2504, if ∪iCCAi> 0, the other convex hull B ′ is released. The union of the convex elements CBj of the non-convex polyhedron B is expressed as ∪jCBj. Then
Distance r (CBj, A ') between convex hull A' and each convex element CBj
Is a subset ＢjCCBj of convex elements of which are not more than εCCH. Also, the flag contflgCCB1 = 1 is set (step 2506). Thereafter, it is checked whether the number of convex elements constituting the subset ∪jCCBj is 0 (step 250).
7). ∪ If jCCBj = 0, r (CBj,
A ′), a convex element CBk that gives the minimum distance MINjr (CBj, A ′) is obtained, the closest point between the convex element CBk and the convex hull A ′ is obtained, and the closest point is determined as a non-convex polyhedron A, B It is output as the point of closest approach (step 2508).

FIG. 65 (b) shows steps 2506 to 250
FIG. 8 is a specific explanatory diagram of FIG. The previous closest point information in the continuous interference check is the convex element CBj of the non-convex polyhedron B.
Is held as an attribute. In step 2506, co
The flag of ntflgCCBj = 1 is set, and step 2508 is executed.
The interference check between (CAi, B ') is a continuous type. In step 2507, if ∪jCCBj> 0, convex elements CCAPp and CCBq that give the minimum distance MINi, jR (CCAi, CCBj) between subsets ∪iCCAi and ∪jCCBj are obtained, and the closest approach point therebetween is obtained. , Is output as the point of closest approach between the non-convex polyhedrons A and B.
Also, all flags contflgA ', contflgB', contflg
CCA1 and contflgCCBj are reset to 0 (step 2509). Thereafter, the process returns to the beginning and the subsequent processes are repeated. FIG. 66 is an explanatory diagram showing the entire flow described above.

(S) Interference Check Sub-Algorithm (Dynamic Construction / Release of Convex Hull and Envelope Sphere Interference Check) For a non-convex polyhedron, a convex hull is defined as the smallest convex polyhedron that envelopes it. When the distance between the non-convex polyhedrons is sufficiently large, an interference check is performed between the convex envelope spheres that envelope the convex hull, and when the convex envelope spheres start to interfere with each other, an interference check between the convex hulls is performed. When the convex hulls start to interfere with each other, an envelope sphere interference check and a convex polyhedron interference check are performed on the convex elements constituting the non-convex polyhedron. The envelope sphere interference check and the configuration / cancellation of the convex hull are dynamically switched according to the distance between the non-convex polyhedrons. FIG. 67 is a processing flow of dynamic configuration / cancellation of a convex hull and an envelope sphere interference check. Each non-convex polyhedron A, B
Of the envelope spheres RA, RB and the centers of the envelope spheres PCA, PCB (steps 2501, 2502), and the distance r between the centers of the envelope spheres is determined by the following equation: r = | PCA-PCB |, and r ≦ (RA + RB) Check (step 2503).

If r> (RA + RB), it is determined that there is no interference, and r is output as the distance between the closest approach points (step 2).
504). If r ≦ (RA + RB), an interference check process (closest search process) is performed between the convex hulls A ′ and B ′ of the non-convex polyhedrons A and B, and a distance r (A ′, B ′) between the closest approach points )
Ask for. Next, the magnitudes of r (A ', B') and εCH are determined (step 2505). r (A ′, B ′)> ε
In the case of CH, since the convex hulls A 'and B' do not interfere with each other, the point of closest approach between the convex hulls A 'and B' is set as the point of closest approach between the non-convex polyhedrons A and B and is output (step 2506). On the other hand, r
If (A ′, B ′) ≦ εCH, one convex hull, for example, the convex hull A ′ is released because the convex hulls interfere with each other. The union of the convex elements CAi of the non-convex polyhedron A is expressed as ∪iCAi. Next, an interference check between the envelope sphere of each convex element CAi and the envelope sphere of the non-convex polyhedron B is performed, and each interfering convex element CAi
An interference check is performed between i and the convex hull B '. Thereafter, the distance r (CAi, B ') between the convex hull B' and each convex element CAi is ε.
A subset ∪iSCCAi of convex elements below CCH is obtained (step 2507).

Next, it is checked whether the number of convex elements constituting the subset ∪iSCCAi is 0 (step 250).
8). ∪ If iSCCAi = 0, r (CAi,
B ′), a convex element CAk that gives the minimum distance MINir (CAi, B ′) is determined, the closest point between the convex element CAk and the convex hull B ′ is determined, and the closest point is defined as a non-convex polyhedron A, B It is output as the point of closest approach (step 2509). ∪iSC
If CAi> 0, the other convex hull B 'is released. The union of the convex elements CBj of the non-convex polyhedron B is expressed as ∪jCBj. Next, the envelope sphere of each convex element CBj and the non-convex polyhedron A
Check for interference between the envelope spheres of
An interference check is performed between Bj and the convex hull A '. Thereafter, a subset 凸 jSCCBj of convex elements whose distance r (CBj, A ′) between the convex hull A ′ and each convex element CBj is equal to or smaller than εCCH is obtained (step 2510). Then, the subset ∪jSCC
It is checked whether the number of convex elements constituting Bj is 0 (step 2511). Ｒ If jSCCBj = 0, r
(CBj, A ') minimum distance MINir (CBj,
A ′) is obtained, the closest point between the convex element CBk and the convex hull A ′ is obtained, and the closest point is output as the closest point between the non-convex polyhedrons A and B (step 251).
2).

However, when ∪jSCCBj> 0,
Minimum distance between subsets ∪iSCCAi and ∪jSCCBj
The convex elements SCCAp and SCCBq that give MINi, jr (SCCAi, SCCBj) are obtained, the closest approach point between them is obtained, and output as the closest approach point between the non-convex polyhedrons A and B (step 2513). Thereafter, the process returns to the beginning and the subsequent processes are repeated. The interference check can be speeded up by incorporating the continuous interference check processing of the convex polyhedron shown in FIG. 63 into the algorithm shown in FIG.

(T) Structure of Interference Check System FIG. 68 is a diagram showing the structure of the interference check system of the present invention. Reference numeral 21 denotes a three-dimensional CAD system for generating a shape model and outputting a polygon data file. 23 is a memory that stores convex element data obtained by pre-processing, a proximity point multi-tree list, a proximity point linear list, etc., 23 is a proximity point multi-tree list creation unit that creates a proximity point multi-tree list from a polygon data file, and 24 is A near-point linear list creation unit that generates a near-point linear list from a near-point multitree list, 25 is a convex decomposition unit that decomposes a non-convex polyhedron into a set of convex elements, 26 is an interference check unit, and 27 is a near-point linear list. A list input / output unit 28 that outputs the data to an external recording medium, reads the data as appropriate, and expands the data in the memory 22. Medium.

(U) Field of Application of the Present Invention The present invention can be applied in the following fields. (a) CAD system for mechanical design In mechanical design, inadvertent interference often occurs when assembling products. In order to prevent such a situation in advance, it is important to carefully check the bonding relationship between components and the margin on the CAD system for mechanical design. By incorporating the real-time interference check system into the CAD system for mechanical design, it is possible to perform a preliminary check in a form close to an actual product. (b) Path planning for mobile robots Mobile robots such as manipulators and self-propelled vehicles are often driven after performing path planning in advance so as not to collide with other objects. For example, in assembling parts using a manipulator, it is necessary to plan a path while checking interference between parts and interference between the part and the manipulator. In addition, a self-propelled robot such as a cleaning robot, a guard robot, or a transport robot needs a path plan that avoids collision with an obstacle such as a wall, a pillar, or a desk when moving between points. In such a case, it is effective to incorporate a high-speed interference check system into the manipulator or the robot control unit and perform a check in advance.

(C) Creation of Animation in Multimedia In the field of animation, creation of highly realistic animation using a graphic computer is desired. For example, to make an android model walk, it is necessary to solve a contact problem between the android model and the ground, and to simulate an automobile collision, it is necessary to solve an interference problem between automobiles. (d) Game software Conventional game software was mostly two-dimensional, but in the future it is expected that those that use graph computers and display three-dimensionally will become mainstream. In game software, for example, there are many interference problems between objects such as a collision between a missile and a fighter in a shooting game and a collision between cars in a racing game. The real-time interference check system of the present invention provides a powerful means in the above application field. 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.

[0168]

As described above, according to the present invention, a near-point linear list is created in the preprocessing, and vertices close to the closest point closest to the latest point obtained at the time of interference check are obtained from the near-point linear list. Since the closest approach point at the next time from the middle is continuously searched, it is not necessary to perform the closest approach point search processing on all vertices, so that the interference check can be performed at high speed. Further, since an envelope sphere or a convex hull is generated and the interference check is performed by using these envelope spheres or the convex hull when the sphere is apart, a high-speed interference check can be performed.

[Brief description of the drawings]

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

FIG. 2 is an exploded explanatory view of a convex polyhedron into surface polygons (in the case of a hexahedron).

FIG. 3 is an explanatory view of a convex polyhedron data structure for searching for a point of closest approach (in the case of a hexahedron).

FIG. 4 is a processing flowchart of a first closest approach point search method of the present invention.

FIG. 5 is an explanatory diagram of convex polyhedral data input.

FIG. 6 is a configuration diagram of a first closest point searching device.

FIG. 7 is an explanatory diagram of triangulation of a convex polyhedron.

FIG. 8 is an explanatory diagram of triangulation of a polygon.

FIG. 9 is a processing flowchart of a second closest approach point search method.

FIG. 10 is a configuration diagram of a second closest point searching device.

FIG. 11 is an explanatory diagram of a merging process.

FIG. 12 is an explanatory diagram of a merging data structure.

FIG. 13 is a flowchart of a merging algorithm.

FIG. 14 is an explanatory diagram of convex hull data.

FIG. 15 is an explanatory diagram of merging processing by a task.

FIG. 16 is an explanatory diagram of a merging process using a While sentence.

FIG. 17 is an explanatory diagram of the present invention when the environment changes dynamically.
(Part 1).

FIG. 18 is an explanatory diagram of the present invention when the environment changes dynamically.
(Part 2).

FIG. 19 is an explanatory diagram of merging and recovery processing.

FIG. 20 is an explanatory diagram of a recovery process using a While statement.

FIG. 21 is an overall processing flowchart of searching for a point of closest approach between non-convex polyhedrons.

FIG. 22 is a configuration diagram of a device for searching for a point of closest approach between non-convex polyhedrons according to the present invention.

FIG. 23 is an explanatory diagram of a first method of continuous search for the closest point between non-convex polyhedrons.

FIG. 24 is a flowchart of a first closest point continuous search process between non-convex polyhedrons.

FIG. 25 is an explanatory diagram of a second method of continuous search for the closest point between non-convex polyhedrons.

FIG. 26 is a flowchart of a second closest point continuous search process between non-convex polyhedrons.

FIG. 27 is a system configuration diagram.

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

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

FIG. 30 is a flowchart of the Merge process.

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

FIG. 32 is a process flow of a second embodiment of the pre-decomposition processing.

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

FIG. 34 is a processing flow of a third embodiment of the pre-decomposition processing.

FIG. 35 is an explanatory diagram of a result of convex division when there is a negative object.

FIG. 36 is a processing flow of the fourth embodiment of the pre-decomposition processing.

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

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

FIG. 39 is a flow chart of a Merge process.

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

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

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

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

FIG. 44 is a processing flow of a first modified example of convex decomposition.

FIG. 45 is a processing flow of a second modified example of the convex decomposition.

FIG. 46 is an example of a proximity point list.

FIG. 47 is a pre-processing flow for creating a proximity point linear list.

FIG. 48 is an explanatory diagram of a rectangular parallelepiped divided into triangular polygons and polygon data.

FIG. 49 is an explanatory diagram of polygon data for each convex element.

FIG. 50 is an explanatory diagram of an algorithm for generating a proximity point linear list.

FIG. 51 is another explanatory diagram of the algorithm for generating the proximity point linear list.

FIG. 52 is an explanatory diagram of creation of a proximity point linear list.

FIG. 53 is an example of a proximity point multi-tree list.

FIG. 54 is a preprocessing flow for creating a proximity point multi-tree list.

FIG. 55 is an explanatory diagram of a dump file format of a proximity point linear list.

FIG. 56 is a flowchart of a pre-check algorithm using an envelope sphere.

FIG. 57 is an explanatory diagram of a basic concept of the Gilbert method.

FIG. 58 is a flowchart of a continuous interference check algorithm for a convex polyhedron.

FIG. 59 is an explanatory diagram of a non-convex polyhedron.

FIG. 60 is an explanatory diagram of a basic concept of dynamic configuration / cancellation of a convex hull.

FIG. 61 is an explanatory diagram of interference check between a convex hull and a convex element.

FIG. 62 is a flowchart of a dynamic hull dynamic configuration / cancellation algorithm.

FIG. 63 is a flowchart of dynamic configuration / release of a convex hull and a continuous polyhedron continuous interference check.

FIG. 64 is an explanatory diagram of a continuous interference check between convex hulls.

FIG. 65 is an explanatory diagram of a continuous interference check between a convex element and a convex hull.

FIG. 66 is an explanatory diagram of interference check between convex elements.

FIG. 67 is a flowchart of an algorithm for dynamically constructing / releasing a convex hull and checking for an envelope sphere interference.

FIG. 68 is a configuration diagram of an interference check system.

FIG. 69 is an explanatory diagram (part 1) of points to be solved by the closest approach algorithm.

FIG. 70 is an explanatory diagram (part 2) of points to be solved by the closest approach point algorithm;

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

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

FIG. 73 is an explanatory diagram of the Gilbert method.

FIG. 74 is an explanatory diagram of a numerical test result of the Gilbert method.

FIG. 75 is an explanatory diagram of a search for a point of closest approach between non-convex polyhedrons by the Gilbert method.

[Explanation of symbols]

 22a: polygon data storage unit 22b: proximity point linear list storage unit 24: proximity point linear list creation unit 26: closest point search processing unit

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Shiro Nagashima 4-1-1, Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa Prefecture Inside Fujitsu Limited (72) Inventor Tsutomu Maruyama 4-chome, Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa No. 1 No. 1 Fujitsu Limited F term (reference) 5B046 FA07 FA16 5L096 BA04 BA05 FA66 FA77

Claims (5)

[Claims] 1. An apparatus for searching for a point of closest approach which continuously checks for points of closest approach between convex polyhedrons to check for interference between them, means for inputting vertex coordinates of all polygons covering the convex polyhedron, Is provided in a first direction (next direction), and a vertex group connected to each vertex via a polygon side is linked to the vertex in a second direction (branch direction). Proximity point linear list creation means for creating a list, a proximity vertex acquisition unit for obtaining a vertex that is closest to the closest approach point obtained latest from the proximity point linear list, a closest approach point at the next time from among the obtained vertices A closest point searching means for searching for an interference and performing an interference check. 2. A closest approach point search for decomposing each of the first and second non-convex polyhedrons into a convex polyhedron and continuously searching for the closest approach point between the convex polyhedrons to check for interference between the non-convex polyhedrons. In the apparatus, for each convex polyhedron, vertices of all polygons covering the convex polyhedron are linked in a first direction (next direction), and a vertex group connected to each vertex via a polygon side is defined in a second direction (branch).
a near-point linear list creating means for creating a near-point linear list having a data structure linked to the vertices in the h-direction), for each of the non-convex polyhedrons, among the vertex coordinate values of the non-convex polyhedron, Envelope sphere generating means for obtaining the maximum coordinate value and the minimum coordinate value of the non-convex polyhedron based on the maximum coordinate value and the minimum coordinate value, and the envelope spheres of the first and second non-convex polyhedrons interfere with each other. After the interference, the non-convex polyhedron is searched for the closest approach point between the convex polyhedrons obtained by decomposing the non-convex polyhedron. From the list,
Closest point searching means for searching for the closest point at the next time from among the vertices, and an interference check unit for performing an interference check using the shortest distance between the closest points between the convex polyhedrons. The closest point search device. 3. A convex hull generating unit that generates a minimum convex polyhedron (convex hull) wrapping each of the non-convex polyhedrons, wherein the checking unit interferes with an envelope sphere of the first and second non-convex polyhedrons. Thereafter, it is checked whether or not the convex hulls of the first and second non-convex polyhedrons interfere with each other.
After the second convex hulls interfere with each other, a search is made for the closest point between the convex polyhedrons obtained by decomposing the non-convex polyhedron. 3. The closest point searching device according to claim 2, wherein the shortest one is used for interference check. 4. A closest approach point search for decomposing each of the first and second non-convex polyhedrons into a convex polyhedron and continuously searching for the closest approach point between the convex polyhedrons to check for interference between the non-convex polyhedrons. In the apparatus, for each of the convex polyhedrons, vertices of all polygons covering the convex polyhedron are linked in a first direction (next direction), and a vertex group connected to each vertex via a polygon side is defined in a second direction (branch).
a near-point linear list creating means for creating a near-point linear list having a data structure linked to the vertices in the h-direction); a convex hull for generating a minimum convex polyhedron (convex hull) enclosing each non-convex polyhedron Generating means, checking means for checking whether the convex hulls of the first and second non-convex polyhedrons interfere with each other, searching for the closest point between the convex polyhedrons after the interference, and approaching the closest approach point obtained latest The closest point search means for obtaining the vertices from the linear list of the close points and searching for the closest point at the next time from the vertices. The interference check using the shortest distance between the closest points between the convex polyhedrons. An interference check unit that performs the following. 5. The checking means, after the convex hulls interfere with each other, cancels one convex hull and checks the interference between each convex polyhedron obtained by decomposing the non-convex polyhedron and the other convex hull. After the convex polyhedron interferes with the other convex hull, the closest approach point searching means cancels the other convex hull and determines the closest point between the convex polyhedrons obtained by decomposing each non-convex polyhedron. 5. The closest approach point searching device according to claim 4, wherein the search is performed, and the interference check unit performs the interference check using the shortest distance between the closest approach points between the convex polyhedrons.