Assembly Sequences for Polyhedra

Algorithmica, 13: 539 -552, 1995

Assembly Sequences for Polyhedra Achim Schweikard, Randall H. Wilson Robotics Laboratory, Department of Computer Science Stanford University Stanford, CA 94305-4110 February 15, 1995 Abstract

The problem of nding sequences of motions for the assembly of a given object consisting of polyhedral parts arises in assembly planning. We describe an algorithm to compute the set of all translations separating two polyhedra with n vertices in O(n4 ) steps and show that this is optimal. Given an assembly of k polyhedra with a total of n vertices, an extension of this algorithm identi es a valid translation and removable subassembly in O(k2 n4 ) steps if one exists. Based on the second algorithm a polynomial time method for nding a complete assembly sequence consisting of single translations is derived. An implementation incorporates several changes to achieve better average-case performance; experimental results obtained for simple assemblies are described. Keywords: assembly planning, arrangement computation in the plane, separating polyhedra.

Introduction The problem of nding sequences of motions for the assembly of a given object consisting of polyhedral parts arises in assembly planning. This problem can be regarded as a motion planning problem with multiple moving objects. In this general form, the problem involves many degrees of freedom. Since known methods for motion planning allowing general motions are exponential in the number of degrees of freedom, it is useful to restrict the type of motion considered. Here we will impose the following restrictions:

 Each step in an assembly sequence joins two subassemblies. Two sub-

assemblies which have been joined in a previous step are not moved relative to each other in subsequent steps. 1

 At each step in an assembly sequence, a single translation moves the rst subassembly to its nal position relative to the second subassembly.

These restrictions embody practical constraints often imposed on assembly sequences by manufacturing processes; complicated assembly motions and operations joining more than two subassemblies make assembly more dicult and raise manufacturing costs. Our algorithm will report a valid sequence of such translational motions and the corresponding subassemblies if such a sequence exists. We will address the following subproblems: 1. Given two polyhedra, compute the set of all translations separating these polyhedra. 2. Given an assembly A of several polyhedra, decide whether there is a direction d and a subassembly S  A such that a translation along d separates S from the remaining parts A n S. Problem 2 is the translational partitioning problem. Given a method for solving the second problem, we will show that complete assembly sequences for polyhedral parts can easily be computed. Example: An example for problem 2 above is shown in gure 1. None of the parts in the nal assembly shown in the gure can be separated from the remaining parts by a translation involving a single part; however, the nal assembly can be partitioned by rst moving a pair of parts simultaneously, and then separating the parts in the two resulting subassemblies. An assembly plan is then obtained by reversing the disassembly motions. In gure 2, any subset of the cubes C1; : : :; C4 can be removed by a single simultaneous translation from the remaining objects. This second example shows that the number of removable subassemblies is exponential in general. Hence, it is not practical to compute all removable subassemblies explicitly. However, we show that it can be determined in polynomial time whether a removable subassembly exists. Speci cally, we describe an optimal algorithm for solving the rst problem above. The method is then extended to derive a polynomial time algorithm to solve the second problem. Using this procedure, we derive a polynomial time method for nding complete assembly sequences. Finally, an implementation of the above algorithms and the results of various assembly planning experiments are described.

1 Related Work A survey of earlier methods for separating sets in two and three dimensions is given in [15]. In [11] lower bounds on the number of simultaneous translations necessary for separating objects are derived. Dawson [4] shows that two or more star-shaped objects can always be separated by translating the objects in 2

Figure 1: An assembly in which no single part can be removed

z C

1

C

2

C

3

C

4

x

Figure 2: An assembly of cubes

3

dierent directions simultaneously. However, it is shown in [14] that for some assemblies of convex polyhedra, no subassembly may be removed, using general rigid motions, without disturbing the rest of the parts. Homem de Mello and Sanderson [6] give a method to calculate the polyhedral convex cone containing the in nitesimal translations allowed by a set of planar contacts in space. This method only considers contacts between parts, and thus cannot be used to decide whether there is a collision-free extended translation. Krishnan and Sanderson [7] address problem 1 by mapping the set of all unit translations onto a two-dimensional grid, and marking grid elements that correspond to collisions between two polyhedra. Any unmarked elements then represent valid removal translations. However, this method is only accurate to the size of the grid, and cannot be used to nd translations involving contacts between the two parts. Pollack, Sharir and Sifrony [12] consider sequences of translations to separate polygons. The algorithm [12] is limited to planar assemblies of two parts, but is able to nd separating motions consisting of several distinct translations. Toussaint [16] describes an algorithm for separating two simple polygons by a single translation; this is the planar case of problem 1 above. Similarly, Arkin, Connelly and Mitchell [2] address the planar version of problem 2. They use the concept of monotone paths among polygonal obstacles to identify a removable subassembly of simple polygons in the plane. The methods in [2] do not extend directly to the three-dimensional case. However, Mitchell has independently shown that directions for partitioning an assembly can be found in polynomial time [10]. In this paper we give an algorithm to nd the set of translations separating two polyhedra in O(n4) time and show that this is optimal. A method for nding complete assembly sequences based on this algorithm is analyzed theoretically as well as empirically and improvements for applications are described. The analytic bounds derived consider the number of parts, the number of vertices in the representation of the parts, and the size of the coordinates in the input description.

2 Separating Two Polyhedra In this section a method for nding the set of translations separating two polyhedra will be derived. Let P and Q be non-intersecting polyhedra in given spatial placement. The translations of P to in nity can be represented by the points on the unit sphere S 2 in three-dimensional space. A translation separating P from Q is a point d on the unit sphere such that P can be translated to in nity along d without intersecting Q, i.e. p + td is not in Q for each p in P and each t  0. The set C(P; Q) = fq ? p j p 2 P; q 2 Qg is called the con guration obstacle of P with respect to Q. This set is a polyhedron [9]. During a translation of P to in nity along d, a point p 2 P moves along the ray p + td. If p intersects Q 4

Q P d O

O Ds C ( P, Q )

a)

b)

Figure 3: a) Polygons P; Q. b) Con guration obstacle C(P; Q) and set Ds representing translations separating P from Q. during this translation, there is a t  0 such that p + td = q for a q 2 Q. Thus td = q ? p, and the ray in direction d crosses C(P; Q). C(P; Q) does not contain the origin, since q ? p = 0 for p 2 P; q 2 Q would imply p = q, i.e. P intersects Q in its initial placement. In the notation of [9], P is the moving object, Q is an obstacle and the origin is the reference point of P. The set of translations along which P collides with Q is the projection of C(P; Q) on the unit sphere S 2 under a central projection from the origin. The complement of this set is the set of all translations Ds separating P from Q. An example for the planar case is shown in gure 3. Figure 3a) shows polygons P and Q. O denotes the origin. The con guration obstacle C(P; Q) is shown in gure 3b). The point d represents a translation, along which P will not intersect Q. The ray from the origin through d does not cross C(P; Q). The segment Ds represents translations separating P from Q. To compute the set Ds explicitly, we assume that the faces of P and Q are described as unions of triangles. Such triangulations are often computed in geometric modelling systems. We then compute the con guration obstacle C(Ti; Tj ) for each pair (Ti ; Tj ) of triangles, where Ti belongs to a face of P and Tj to a face of Q. When projecting C(Ti ; Tj ) we obtain regions Rij on the sphere. The regions Rij are bounded by segments of great circles. These segments determine an arrangement on the sphere and partition the sphere into faces. Each such face is open and contains no points on any of the bounding segments. The faces are regular in the following sense: the pairs of triangles Ti ; Tj from P and Q that collide in direction d are the same for all translations d in a face f. 5

2.1 Crossing Rules

To nd translations separating P and Q, we rst compute the faces in the decomposition of the sphere which is induced by the boundaries of regions Rij . A face is represented as a list of oriented bounding edges. To simplify the computation, the faces are arranged in an adjacency graph; in this graph, faces and edges are represented by nodes, and nodes for adjacent elements are linked. In this way we can identify the neighbors of a face and the edge shared by two neighboring faces. Let p(f) be the number of pairs of triangles that collide along translations in face f. If the edge e separates two faces f and f , we have the following crossing rules for p(f) and p(f ):  If e belongs to the boundary of a region Rij and f is on the interior side of e, then p(f ) = p(f) + 1.  If f is on the exterior side of e, then p(f ) = p(f) ? 1. In some cases, several edges from dierent regions Rij may coincide. If two faces f and f are separated by an edge e bounding several regions, then p(f ) = p(f) ? g + h, where g is the number of regions on the same side of e as f and h is the number of regions on the same side of e as f . In the algorithm below, translations are represented as points on two parallel planes instead of points on the unit sphere. Con guration obstacles C(Ti ; Tj ) are projected to the planes z = 1 and z = ?1, again under a central projection from the origin. When projecting C(Ti; Tj ) we obtain planar regions Rij in one or both planes z = 1 and z = ?1. The regions Rij are bounded by line segments and rays. The bounding segments and rays determine an arrangement in each plane and partition the two planes into faces ( gure 4). The faces are not necessarily convex. The algorithm to nd all faces representing valid translations proceeds as follows. Input: Polyhedra P and Q; P and Q are speci ed as sets of triangles T1; : : :; Tr and U1 ; : : :; Us respectively. Output: A list of faces in the planes z = 1 and z = ?1 representing translations that separate P and Q. For each plane z = 1 and z = ?1, 1. For each pair of triangles Ti ; Uj , compute the projection Rij of C(Ti ; Uj ) on the plane. 2. Calculate an adjacency graph representation for the faces, orienting the edges as described above. 3. For an arbitrarily selected face f0 , compute the number p(f0 ) of regions Rij containing f0 . 0

0

0

0

0

0

0

0

0

6

C (Ti , Tj )

C (Tr , Ts )

Rrs

Rij

f

z=1

O

Figure 4: Projections Rij ; Rrs of con guration obstacles C(Ti ; Tj ); C(Tr ; Ts ) and face f in planar arrangement. 4. Perform a depth- rst traversal of all the faces in the arrangement by stepping from f0 to neighboring faces. To step from a face f to a neighboring face f , calculate p(f ) from p(f) using the crossing rules above. After visiting a face, it is marked and not visited again. For each face f where p(f) = 0, output the face f and continue. 0

0

2.2 Computing Time

Let n be the number vertices of P and Q. Then there are O(n) triangles representing their faces. There are O(n2) regions Rij , each with a constant number of edges. Therefore step 1 requires O(n2 ) operations. A graph representing faces and adjacency relationships in an arrangement of m segments in the plane can be computed in O(m2 ) steps and has O(m2 ) faces [3, 5]. Here m = O(n2), so the number of faces and the computing time for step 2 are O(n4). Each region Rij has a constant number of boundary segments, so testing the initial face f0 for inclusion in all regions requires O(n2) operations. Finally, the depth- rst search steps over each edge at most twice, each step taking constant time. Since the number of arrangement segments is O(n4 ), the computing time for step 4 is O(n4). The optimality of this algorithm directly follows from an example given by Pollack, Sharir and Sifrony [12]. The example in [12] concerns two polygons P and Q with r and s edges respectively ( gure 5). The number of connected components in the complement of the con guration obstacle corresponding to P and Q is proportional to r2s2 . In our case the polygons P and Q are regarded as polyhedra of zero volume, and r; s = n; the following holds equally if P and Q are polyhedra with suciently small thickness. We place P in a plane p and Q in a plane parallel to p, but distinct from p. Then the plane containing 7

...

P

...

Q

...

...

Figure 5: Polygons from Pollack et. al. [12] the con guration obstacle of P with respect to Q does not contain the origin, so the projection of the con guration obstacle of P with respect to Q on the sphere S 2 partitions S 2 into (n4 ) connected components. Therefore the set of translations separating P from Q consists of (n4 ) connected components. We now have the following lemma: Lemma 1 The set of all translations separating P from Q, where P and Q are polyhedra each with n vertices can be found in O(n4) steps and this is optimal. To nd separating translations in which parts touch each other, open polyhedra can be considered in the above algorithm. In this case the edges and vertices of an arrangement may correspond to valid directions. A value counting the number of colliding triangles is associated with every face, edge, or vertex. The arrangement can again be computed and traversed in O(n4) steps.

3 Blocking Graphs Problem 2 stated in the introduction concerns an assembly A of polyhedra P1; : : :; Pk. The methods described in the previous section can be extended to an algorithm for nding a translation d and a proper subassembly S of A such that d separates S from the remaining parts A n S, or deciding that no such pair (d, S) exists. 8

d2

d1

1

3

P1

P2

P3

P4

2

1

4

3

G(d1 )

2

4 G(d2 )

Figure 6: Directions d1 and d2 and associated graphs G(d1); G(d2). Let d be a point on the unit sphere. The intersection relationships between all parts P1 ; : : :; Pk which will occur when translating parts in direction d are represented by a directed graph G(d). Thus the graph G(d) is associated with the particular direction d. Nodes in G(d) represent parts. If the part Pi will intersect part Pj during translation d, then a directed arc in G(d) points from node Pi to node Pj . A node Pj is a successor of a node Pi in the graph G(d) if there is a path from Pi to Pj via a sequence of directed arcs from node Pi to Pj . By convention, we include each node into the set of its successors. A graph is strongly connected if each pair of nodes is connected by a path. In order to test whether any parts can be removed in direction d we only have to test whether G(d) is not strongly connected, i.e. whether there is a node in G(d) not having all other nodes among its successors. The successors of this node can then be removed in direction d. Example: Figure 6 shows two distinct directions d1 and d2 and an assembly A of four parts. When P1 is moved in direction d1, then P1 will collide with P2 and P3. P1 will not collide directly with P4 during this translation, but P2 and P3 will collide with P4. Thus, no direct arc points from P1 to P4, but nevertheless P4 is a successor of P1 . For direction d1, we nd that the successor set of each node is the full set P1 ; : : :; P4 of nodes, so that no subassembly can be removed in direction d1. The graph for direction d2 is also shown. In this case the successor set of P1 is given by fP1 ; P2g, so that the subassembly S = fP1; P2g can be removed in direction d2. 9

4 Partitioning an Assembly To derive an algorithm for solving Problem 2, we compute con guration obstacles for pairs of parts. Projecting the con guration obstacle for a pair (Pi ; Pj ) gives a region Rij in the plane. The boundary segments of the regions thus obtained partition the plane into faces. Note that the graphs de ned above will remain constant within each face. By testing the graph for an arbitrary point in each face it can be determined whether there is a removable subassembly. Let e be an edge separating separating neighboring faces f and f . e is part of the boundary of a region Rij . Rij is the projection of the con guration obstacle for Pi and Pj . The graphs G(f) and G(f ) for f and f are related by the following crossing rules:  If we step from the exterior of the region Rij to the interior by crossing e then G(f ) is obtained from G(f) by adding an arc between nodes i and j.  If we step to the exterior of the region, then an arc is deleted. 0

0

0

0

4.1 Finding a Removable Subassembly

Instead of projecting con guration obstacles to two planes z = 1 and z = ?1 it suces to consider only one of these planes: If a translation d separates a subassembly S from A n S, then ?d separates the subassembly A n S from S. The following algorithm computes a removable subassembly, or reports that no such subassembly exists: Input: Polyhedral parts P1; : : :; Pk of an assembly A. Output: A direction d and a subassembly S of P1; : : :; Pk such that the parts in S can be removed in direction d, if such a direction exists. 1. Calculate the faces and adjacency relationships induced by the boundaries of regions Rij on the plane z = 1. 2. Compute the graph G(f0 ) for an initial face f0 . 3. Perform a depth- rst traversal of the adjacency graph for the faces, computing G(f) for each new face f. If any graph G(f) is not strongly connected, output the successor set of a node not having all other nodes among its successors and a point d in f.

4.2 Computing Time

We assume that the total number of vertices in the given assembly A is n. The faces determined by projected regions can be calculated in O(n4) steps. The initial graph G(f0 ) can be found in O(n2) steps. There are k parts, so each graph has k nodes. Testing whether a graph is strongly connected takes O(k2 ) steps [1]. 10

y

R(4,1)

R(3,1) R(4,2)

R(2,1) R(3,2) R(4,3)

R(1,2) R(2,3) R(3,4)

R(1,3) R(2,4)

x

R(1,4)

Figure 7: The arrangement for the assembly in gure 2 There are O(n4 ) faces in the arrangement, and traversing the adjacency graph requires O(k2n4 ) operations. We now have the following lemma:

Lemma 2 Let A = fP1; : : :; Pk g be a set of k polyhedra with a total of n ver-

tices. It can be decided in O(k2n4 ) steps whether there is a proper subassembly of A that can be translated to in nity without intersecting the remaining parts. An appropriate subassembly and direction can be computed in the same number of steps.

As an example, consider the simple con guration of four cubes aligned along the x-axis in gure 2. The corresponding planar arrangement consists of 12 polygons in each of the planes z = 1 and z = ?1; several of these polygons coincide. Figure 7 shows the plane z = 1. The projected con guration obstacle corresponding to cubes C1 and C4 is the region R1;4 and is bounded by a line segment and two rays. Figure 8a shows the graph G(R1;4). R1;4 is contained in R1;2 and R1;3, so there are arcs in the graph from node 1 to nodes 2, 3, and 4. R1;4 is contained also in R2;4, R2;3, and R3;4. Since node 4 has no successors, it is a removable subassembly for translations in R1;4. If cubes C2 and C4 represent a single part C24, the graph in gure 8b results. Nodes 24 and 3 form a strongly connected component, so cubes 2, 3, and 4 must be removed simultaneously for translations in R1;4.

11

Figure 8: Graphs for region R1;4 where (a) C1; : : :; C4 can be moved independently (b) C2 and C4 must be moved simultaneously

5 Finding Assembly Sequences The above method can be used to decide whether there is a complete assembly sequence for an object with polyhedral parts. Here each subassembly can only be removed by a single translation, but each translation in the sequence can involve one or more parts, and be in a dierent direction.

Lemma 3 It can be decided in O(k3n4) steps whether polyhedra P1; : : :; Pk can

be separated completely using motions where each subassembly is removed from the remaining objects by a single translation.

Proof: Assume that A = fP1; : : :; Pkg can be disassembled. Applying the method of the previous lemma to A gives two subassemblies, each consisting of one or more parts. Each application increases the number of subassemblies by one, and the nal number of subassemblies is k. Therefore the above method is applied k ? 1 times.2 Finally, let b be a bound for the number of binary digits used to represent the coordinates of vertices in the input assembly. The size of all intermediate values occurring in the computation is bounded by O(b). Thus using standard algorithms for rational arithmetic we obtain O(k3n4 b2) as a time bound for nding an assembly sequence with the above algorithm. Here all computations can be performed without loss of accuracy.

6 Experimental Evaluation The above methods were implemented in C on a DECstation 5000 with a number of modi cations giving practical improvements. The program was tested on randomly generated assemblies to estimate its characteristics in the average case and nd practical bounds on its application.

6.1 Implementation

A drawback of the algorithm above is the storage requirement: the arrangement may take O(n4) space to store, which is impractical for complicated assemblies. The topological sweep-line algorithm in [3, 5] sweeps over an arrangement of m lines in O(m) space and optimal O(m2 ) time, but cannot be extended directly to the case of line segments instead of lines. Our implementation addresses these problems by performing a vertical line sweep [8, 13] over the arrangement of O(n2 ) line segments. An imaginary vertical 12

line passes over the arrangement. The cells cut by the sweep line in its current position are kept in a sorted list; the initial list is found by sorting the lines by slope. Start points and end points of segments and intersections between two segments are events, kept in a priority queue sorted by x-value. As the sweep-line moves from left to right, events are processed and the list of cut cells is changed accordingly. Each event can be processed in O(log m) time, so the total running time is O((m + I) log m), where I is the number of intersection events. In our case m = n2. Thus the arrangement calculation requires O((n2 +I) log n) steps, where I = O(n4 ). The sweep-line algorithm maintains the graph G(f) for each face cut by the vertical line. The graphs for faces intersecting the initial sweep-line are propagated down from an initial face at the top of the sweep-line. To process an event, the graph for a new face is calculated by stepping from the face above it in the sweep-line, as described in section 4. Thus the graphs for all faces in the arrangement are calculated and checked without keeping the whole arrangement in memory. The total computing time for nding an appropriate subassembly using the modi ed algorithm is O(k2 n4 + n4 log n). Figure 9 illustrates the processing of an intersection event. The interior of region R2;3 is below edge e1 , and edge e2 is the lower boundary of region R1;3. The graphs for faces f1, f2 , and f3 have already been computed. When the sweep line processes the intersection of e1 and e2 at point p, the face f4 is entered. Edge e2 is between f1 and f4 in the new sweep line, so G(f4 ) is computed by stepping over e2 from G(f1 ). The interior of R1;3 is above e2 , so G(f4) is obtained from G(f1 ) by deleting the arc from node 1 to node 3. Nodes 1 and 2 form a stongly connected component of G(f4 ), so the corresponding parts are a removable subassembly. The implementation generates con guration obstacles for blocks instead of triangles; however, the arrangement computation applies to the general case.

6.2 Experiments

To evaluate the practical computing bounds on the implementation, n random disjoint blocks were generated and linked together to form k complex objects for values of n ranging between 4 and 128 and k ranging between 2 and 16 ( gure 10). Links were generated at random. A link between two blocks signi es that the blocks can only be moved simultaneously. Removable subassemblies were identi ed for these assemblies using the described implementation of the above method. Note that n denotes the number of blocks in table 10; the number of vertices considered is 8n. Tables 1 and 2 show the computing times and storage requirements observed. For each value of n and k, 32 samples were run and the average, minimum, and maximumrunning times recorded (t, tmin , and tmax , respectively); smax denotes the maximum storage needed. In all cases the entire arrangement and all graphs were computed instead of stopping at the rst removable subassembly found. 13

f

sweep line 1 1

2

e

1

3 R(2,3)

1 f

2

2

1

p

3

3 f

R(1,3)

e

f

2

1

2

4

3

2

3

Figure 9: An intersection event in the sweep-line algorithm

z

x

Figure 10: An assembly of eight random blocks 14

n t 103t=n4 tmin tmax smax

8 0.6 0.14 0.5 0.6 19644

16 6.7 0.10 5.8 7.4 30908

32 61.7 0.058 55.0 68.9 44163

64 415.3 0.024 408.6 440.8 61816

128 1473.6 0.0054 1455.8 1528.9 88264

Table 1: Computing times for partitioning; k = 4 parts; total number of vertices = 8n. (units: seconds of CPU-time and 1024 Bytes) k t tmin tmax

2 630.4 611.1 649.3

4 834.5 805.5 866.3

4 906.8 864.0 965.4

8 1081.8 992.6 1158.5

16 1608.5 1518.8 1653.4

Table 2: Computing times for partitioning; k = number of parts; number of vertices = 1024. In table 1 the number k of parts is constant, i.e. k = 4, whereas in table 2 the total number of vertices is constant, i.e. the number of blocks in table 2 is 128, while k assumes the values k = 2; 4; 8; 16; 32.

7 Conclusions Several extensions of the described methods might be considered. Unconnected subassemblies usually require more complicated xtures and more dicult manipulation than do connected subassemblies. As a result, connected subassemblies are often preferred in manufacturing planning. By analyzing a connection graph of the assembly, the above algorithm can be extended to generate only subassemblies which are connected.

Acknowledgements This research was funded by DARPA contract N00014-88-K-0620 (Oce of Naval Research) and the Stanford Integrated Manufacturing Association (SIMA). The authors would like to thank Herbert Edelsbrunner for his suggestions concerning the computation of planar arrangements. We would also like to thank Jean-Claude Latombe for his comments on presentation and for bringing the example in gure 5 to our attention.

15

References [1] A. V. Aho, J. E. Hopcroft, and J. D. Ullman. Data Structures and Algorithms. Addison-Wesley, Reading, MA, 1983. [2] E. M. Arkin, R. Connelly, and J. S. B. Mitchell. On monotone paths among obstacles, with applications to planning assemblies. In Proc. of the ACM Symp. on Computational Geometry, pages 334{343, 1989. [3] B. Chazelle, L. J. Guibas, and D. T. Lee. The power of geometric duality. BIT, 25:76{90, 1985. [4] R. J. Dawson. On removing a ball without disturbing the others. Mathematics Magazine, 57(1):27{30, 1984. [5] H. Edelsbrunner. Algorithms in Combinatorial Geometry. Springer, Heidelberg, 1987. [6] L. S. Homem de Mello and A. C. Sanderson. Automatic generation of mechanical assembly sequences. Technical Report CMU-RI-TR-88-19, Robotics Institute - Carnegie-Mellon University, 1988. [7] S. S. Krishnan and A. C. Sanderson. Path planning algorithms for assembly sequence planning. In Int. Conf. on Intelligent Robotics, pages 428{439, 1991. [8] J.-C. Latombe. Robot Motion Planning. Kluwer Academic Publishers, Boston, 1991. [9] T. Lozano-Perez. Spatial planning: A con guration space approach. IEEE Transactions on Computers, C-32(2):108{120, 1983. [10] J. S. B. Mitchell. Personal communication, December 1990. [11] B. K. Natarajan. On planning assemblies. In Proc. of the ACM Symp. on Computational Geometry, pages 299{308, 1988. [12] R. Pollack, M. Sharir, and S. Sifrony. Separating two simple polygons by a sequence of translations. Discrete and Computational Geometry, 3:123{136, 1988. [13] F. P. Preparata and M. I. Shamos. Computational Geometry: An Introduction. Springer-Verlag, 1985. [14] J. Snoeyink and J. Stol . Objects that cannot be taken apart with two hands. In Proc. of the 9th ACM Symp. on Computational Geometry, to appear, 1993. 16

[15] G. T. Toussaint. Movable separability of sets. In G. T. Toussaint, editor, Computational Geometry. Elsevier, North Holland, 1985. [16] G. T. Toussaint. On separating two simple polygons by a single translation. Discrete Computational Geometry, 4:265{278, 1989.

17