Computational

Geometry
Theory and Applications
ELSEVIER Computational Geometry 10 (1998) 249-262

Computing fence designs for orienting parts"

Robert-Paul Berretty a,1, Ken Goldberg b,2, Mark H. Overmars a,
A. Frank van der Stappen a,*
Department of Computer Science, Utrecht University, P.O. Box 80089, 3508 TB Utrecht, The Netherlands
b Industrial Engineering and Operations Research, University of California at Berkeley, Berkeley, CA 94720, USA
Communicated by C.M. Hoffmann; submitted 15 August 1997; accepted 3 December 1997

Abstract
A common task in automated manufacturing processes is to orient parts prior to assembly. We consider
sensorless orientation of a polygonal part by a sequence of fences. We show that any polygonal part can be
oriented by a sequence of fences placed along a conveyor belt, thereby settling a conjecture by Wiegley et al.
(1997), and present the first polynomial-time algorithm to compute the shortest such sequence. The algorithm is
easy to implement and runs in time O(n 3 logn), where n is the number of vertices of the part. © 1998 Elsevier
Science B.V.
Keywords: Robotics; Parts feeding; Fence design; Planning

1. Introduction

Many automated manufacturing processes require parts to be oriented prior to assembly. A part
feeder takes in a stream of identical parts in arbitrary orientations and outputs them in a uniform
orientation. Part feeders often use data obtained from some kind of sensing device to accomplish their
task. We consider the problem of sensorless orientation of parts, in which the initial pose of the part is
assumed to be unknown. In sensorless manipulation, parts are positioned and/or oriented using passive
mechanical compliance. The input is a description of the part shape and the output is a sequence of
open-loop actions that moves a part from an unknown initial pose into a unique final pose. Among the
sensorless part feeders considered in literature are the parallel-jaw gripper [7,10], a single pushing jaw
[2,11,12,14], a conveyor belt with a sequence of (stationary) fences placed along its sides [6,15,17], a

Research is supported by NAT© Collaborative Research Grant CRG 951224.

* Corresponding author.
1Supported by the Dutch Organization for Scientific Research (N.W.O.)
2 Supported in part by the National Science Foundation under IRI-9612491 and by Presidential Faculty Fellow Award
IRI-9553197.

0925-7721/98/$19.00 © 1998 Elsevier Science B.V. All rights reserved.

PII S0925-7721(98)00010-8
250 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262

conveyor belt with a single rotational fence (1JOC) [1], a tilting tray [9,13], and vibratory plates and
programmable vector fields [4,5].
The pushing jaw [2,11,12,14] orients a part by an alternating sequence of pushes and jaw reorienta-
tions. The problem of sensorless orientation by a pushing jaw is to find a sequence of push directions
that will move the part from an arbitrary initial orientation into a single known final orientation. Such
a sequence is referred to as a push plan. Goldberg [10] showed that any polygonal part can be oriented
by a sequence of pushes. Chen and Ierardi [7] proved that any polygonal part with n vertices can be
oriented by O(n) pushes. They showed that this bound is tight by constructing (pathological) n-gons
that require f~(n) pushes to be oriented. Goldberg gave an algorithm for computing the shortest push
plan for a polygon. His algorithm runs in O(n 2) time.
The problem offence design is to determine a sequence of fence orientations (see Fig. 1) such that
the fences with these orientations align the part as it moves down a conveyor belt and slides along
these fences [6,15,17]. The motion of the belt effectively turns each slide into a push action by the
fence in the direction normal to the fence. The fact that the direction of the push, i.e., the normal at
the fence, must have a non-zero component in the direction opposite to the motion of the belt imposes
a restriction on successive push directions. Fence design can be regarded as finding a constrained
sequence of push directions (see Section 2.2 for the actual constraints). The additional constraints
make fence design considerably more difficult than sensorless orientation by a pushing jaw. Wiegley
et al. [17] conjectured that a fence design exists for any polygonal part. They gave an exponential
algorithm for computing the shortest sequence of fences for a given part.

L> %

\ \
f
Fig. 1. Three overhead views of the same conveyor belt and fence design. The traversals for three different initial orientations
of the same part are displayed. The traversals show that the part ends up in the same orientation in each of the three cases.
 R.-P. Berretty et al. /Computational GeometO' 10 (1998) 249-262 251

In this paper, we prove the conjecture that a fence design exists for any polygonal part. In addition,
we give an O(n 3 log n) algorithm for computing a fence design of minimal length (in terms of the
number of fences used). We show that fence designs of length O(n) exist for a large class of parts. The
algorithm is easy to implement and the resulting program returns fence designs for input parts within
a fraction of a second. The program can be tuned to take into account certain quality requirements on
the fence design, like minimum and maximum (successive) fence angles to prevent impractical steep
and shallow fences and a long series of fences on a single side of the belt, which would require an
impractically wide conveyor belt. The cost of the incorporation of quality measures is an increase of
the algorithm's running time to O(n4).
Throughout the paper, we assume zero friction between the part and the fences. Since any push
action acts on the convex hull of the part rather than on the part itself, we assume without loss of
generality that the part under consideration is convex. Furthermore, we assume that the parts do not
have meta-stable edges, i.e., the perpendicular projection of the center-of-mass on an edge does not
intersect a vertex of the edge.
This paper is organized as follows. In Section 2, we first review the key notion of a push plan,
and identify the constraints on the relative push angles for fence design. Section 3.1 discusses an
O(n 3 log n) algorithm for computing the shortest fence design for a part. In Section 4, we focus on a
large class of asymmetric polygonal parts and show that these parts can be oriented by fence designs
of linear length (in the number of vertices). Section 5 generalizes the results of Section 4 to parts with
some kind of symmetry.

2. Push plans and fence designs

2.1. The push function

In this section we focus on the push function of a part. Let P be a convex polygonal part with n
vertices and center-of-mass c. We assume that a fixed coordinate frame is attached to P. Directions
are expressed relative to this frame. The contact direction of a supporting line 1 of P is uniquely
defined as the direction of the normal of I pointing into P. The radius function r : [0, 270 ~ R + maps
a direction ¢ onto the distance from c to the supporting line of P with contact direction ¢ (see Fig. 2).
For a polygonal part, the radius function is a continuous piecewise sinusoidal function, and can be
computed in O(n) time by checking each vertex [12]. The final orientation of a part that is being
pushed can be determined from its radius function.
In most cases, parts will start to rotate when pushed. If pushing in a certain direction does not
cause the part to rotate, then the contact normal at one of its points of contact with the jaw passes
through the center-of-mass [12]. We refer to the corresponding direction of the contact normal as an
equilibrium push direction or orientation. If pushing does change the orientation, then this rotation
changes the orientation of the pushing device relative to the part. We assume that pushing continues
until the part stops rotating and settles in a stable equilibrium pose, which is an equilibrium with a
preimage of non-zero length.
The push function p:[0, 27r) ~ [0, 270 links every orientation ¢ to the orientation p(¢) in which
the part P settles after being pushed by a jaw with initial contact direction ¢ (relative to the frame
attached to P). The rotation of the part due to pushing causes the contact direction of the jaw to
252 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262

r(q,)
i I
~r 4, "*" 2~r
2~
0.51~r I10. / 0.405z"

l(,,)

" ( ~ ) ~
/ ] ~-0.25~
-o.65,~ / ] -o.5,~ I
~r 4~ -~" 27r

Fig. 2. At the top, a polygonal part and its radius function r : [0, 2Tr) ~ R +. The boxed kink in the radius corresponds to
the boxed vertex of the part, which is not a maximum of the radius function• Below, the same part and its push function, in
a circular and regular representation.

change. The final orientation p(qS) of the part is the contact direction of the jaw after the part has
settled. The equilibrium push directions are the fixed points of p.
The push function p of a polygonal part consists of steps, which are intervals I C [0, 27r) for
which p(4~) = C for all 0 C I and some constant C E I. The steps of the push function are easily
constructed from the radius function r. If the part is pushed in a direction corresponding to a point of
non-horizontal tangency of the radius function, then the part will rotate in the direction in which the
radius decreases. The part finally settles in an orientation corresponding to a local minimum of the
radius function. As a result, all points in the open interval I bounded by two consecutive local maxima
of the radius function r map onto the orientation q5 E I corresponding to the unique local minimum
of r on I. (Note that q5 itself maps onto ~b because it is a point of horizontal tangency.) This results
in the steps of the push function. In preparation for the next sections, we define two open intervals
l(v) = {¢ < v [ p ( ¢ ) = v} and r(v) = {¢ > v I P(¢) = v} for each fixed point - or equilibrium
orientation - v of the push function. We refer to these intervals as v's left and right environment,
respectively. The interval l(v) corresponds to the half-step left of v = f(v) and r(v) corresponds to
the half-step right of v = f(v) (see Fig. 2). Note that an equilibrium v is stable if l(v) U r(v) ¢ ~.
Besides the steps, there are isolated points satisfying p(~b) = q5 in the push function, corresponding
to local maxima of the radius function. Fig. 2 shows a polygonal part and its push function. The
 R.-P Berretty et al. / Computational Geometry 10 (1998) 249-262 253

behavior of the part while being pushed is fully described by the push function. In the full version [3]
we show that any step function having only non-zero-length half-steps represents a polygonal part,
and is therefore a valid push function.
A push function p is said to have period d if p(¢) = p((¢ + d) mod27r) for all ¢ E [0,27r). Any
part can only be oriented up to (periodic) symmetry in its push function.
We use the abbreviation p , to denote the (shifted) push function defined by
p~(¢) = p ( ( ¢ + c~) modZTr),
for all ¢ C [0, 27r). Note that p~(¢) is the final orientation of a part in initial orientation ¢ after a
reorientation by ~ followed by a push. We can now define a push plan.

Definition 1. A push plan is a sequence c ~ l , . . . , c~,~ such that p~,~ o . . . op~ (¢) = ~ for all 0 E [0, 27r)
and some fixed 4~ E [0, 27r).

An important property of the push function is monotonicity, or the order preserving property [13].
A sequence $ 1 , . . . , s~ of elements of a set S is ordered if S l , . . . , Sn are encountered in order when
the generating cycle of S is traced once, starting from sl. A function p : S ~ S is monotonic if for
any ordered sequence s l , . . . , s~ the sequence p ( s l ) , . . . , p(sT~) is also ordered.

2.2. Fence design

In this section we address the problem of designing a series of fences fl, • - •, fm that will orient P
when it moves down a conveyor belt and slides along these fences f l , . • •, fro. Let us assume that the
conveyor belt moves horizontally from top to bottom, as indicated in the overhead view in Fig. 4. We
distinguish between left fences, which are placed along the left belt side, and fight fences, which are
placed along the right side. The fence angle/3/ of a fence fi denotes the angle between the upward
pointing vector opposing the motion of the belt and the normal to the fence with a positive component
in upward direction. The motion of the belt turns the sliding of the part along a fence into a push by
the fence. The direction of the push is - by the zero friction assumption - orthogonal to the fence with
a positive component in the direction opposing the motion of the belt. Thus, the motion of the belt
causes any push direction to have a positive component in the direction opposing the belt motion. We
now transform this constraint on the push direction relative to the belt into a constraint on successive
push directions relative to the part.
Sliding along a fence fi causes one of P ' s edges e to align with the fence. The curved tip of the
fence [6] guarantees that e is aligned with the belt sides as P leaves the fence. If fi is a left fence then
e faces the left belt side (see Fig. 3). If fi is a right fence, it faces the right side. Assume fi is a left
fence. At the moment of leaving fi, hence, after the push, the contact direction of fi is perpendicular
to the belt direction and towards the right belt side. So, the reorientation of the push is expressed
relative to this direction. Fig. 3(a) shows that the reorientation c~i+l is in the range (0, 7r/2) if we
choose fi+l to be a left fence. If we take a fight fence fi+l, then the reorientation is in the range
(7r/2, 7r). A similar analysis can be done when P leaves a right fence and the edge e faces the left
belt side. The result is given in the table of Fig. 3(b).
The table shows that the type of fence fi imposes a bound on the reorientation ~i+t. Application
of the same analysis to fences fi-l and fi and reorientation ~i leads to the following definition of a
valid fence design [17].
254 R.-P Berretty et al. / Computational Geometry I0 (1998) 249-262

~ belt direction

'•••. reorientation

0
fi
left
left
0~i+1
(0, :r/2)
(rc/2, 7r)
fi+l
left
right
right (-Tr,-~r/2) left
right (-7r/2, O) right

(a) (b)

Fig. 3. (a) For two successive left fences, the reorientation of the push direction lies in the range (0, 7r/2). (b) The ranges
of possible reorientations of the push direction for all pairs of fence types.

Definition 2. A fence design is a push plan Ogl,... , ~m satisfying for all 1 ~< i < m:
(i) ai C (0, 7r/2) U ( - 7 r , - 7 r / 2 ) ~ o~i+1 ~ (0, 7r/Z) U (7r/2, 7r),
(ii) ai E (-7r/2, 0) U (7r/2, 7r) ~ o~i+1 E (-7r/2, 0) U (-Tr,-Tr/Z).

The push plan on the left in Fig. 4 satisfies the constraints of Definition 2, and is therefore also a
fence design.

3. Computing fence designs

3.1. A graph based approach

As every fence puts the part in a stable equilibrium orientation, the part is in one of these ms -- O(n)
orientations as it travels from one fence to another. Let us label these stable equilibria a o , . . . , am~-l.
After a first fence, the part can be in any of the stable equilibria ao,. • •, ares-1. The problem is to
reduce the set of possible orientations of P to one stable equilibrium ai by a sequence of fences. We
build a directed graph on all possible states of the part as it travels from one fence to a next fence.
A state consists of a set of possible orientations of the part plus the type (left or right) of the last
fence, as the latter imposes a restriction on the reorientation of the push direction. Although there are
0(2 ms) subsets of { a 0 , . . . , ams-i }, we shall see that we can restrict ourselves to subsets consisting of
sequences of adjacent stable equilibria. Any such sequence can be represented by the closed interval
s defined by the first and last stable orientation ai and aj of the sequence. The resulting graph has
O(m 2) nodes.
Consider two graph nodes (s, ~) and (g, ~t), where s = [ai, aj] and g are intervals of stable equilibria
and t and ~t are fence types. Let It,t, be the open interval (of length 7r/2) of reorientations admitted by
the successive fences of types t and t t according to the table in Section 2.2. There is a directed edge
from (s, t) to (s t, t t) if there is an angle a E It,t, such that a reorientation of the push direction by
 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262 255

!
0,701¢ --0.25w

°2
--0.40w

0,10~
o~
--0.32~

Y
0.18~

Fig. 4. The left picture shows a plan for a pushing jaw. The jaw reorientations are (from top to bottom) 0.707r, -0.407r
and -0.327r. The conveyor belt on the right orients the same part. The fence angles, which are measured relative to the
upward vector opposing the direction of belt motion, are -0.257r, 0.207r, 0.107r and 0.187r. (Note that the sequence of fence
orientations is not the same as the sequence of orientations of the pushing jaw because the curved fence tip rotates the stable
edge to become aligned with the belt direction.)

a followed by a push moves any stable equilibrium in s into a stable orientation in d . To check this
condition, we determine the preimage (u, w) _~ d of s ~ under the (monotonic) push function. Observe
that if Isl = aj < w - u, any reorientation in the open interval r = ( u - a~, w - aj) followed by a
push will map s into s'. We add an edge from (s, t) to ( d , t I) if the intersection o f r and the interval
It,t, o f admitted reorientations is non-empty, and label this edge with r :q It,t,. For convenience, we add
a source and a sink to the graph. We connect the source to every node (s, t) in the graph for which s
contains all ms stable equilibria, and we connect every node (s, t) with s -- [ai, ai] to the sink. Every
path from the source to the sink now represents a fence design; a fence design of minimum length
corresponds to a shortest such path.

T h e o r e m 3. The shortest path in the graph corresponds to the shortest fence design, if a fence design
exists.

P r o o f . We prove that each path corresponds to a fence design and vice versa. The theorem follows
immediately if we realize that every edge in the path corresponds to a fence in the design.
( 0 ) If there is a path, we must prove that there is a corresponding fence design. Since there is an
edge from (s, t) to (s', t t) if and only if the successive fences t and E allow for a reorientation that
maps s into s t, this follows immediately from the construction o f the graph.
256 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262

( ~ ) If there is a fence design, we prove there is a path in the graph that represents this fence design.
Let f l , . • •, fN be a fence design. We track the possible orientations of the fence design, and prove
by induction that for every set of possible orientations, there is a node in the graph, and furthermore,
there is a path from the source to such a node. Let Ai denote the set of all possible orientations of P
leaving fi. It is easy to see that for each Ai there are multiple nodes that include the set of possible
orientations.
After the first fence fl, all stable equilibria are possible. Since we added edges from the source to
all nodes containing all stable orientations, these nodes are reachable.
We now assume that for fence fi having type t in our fence design the nodes (s, t) with s _D Ai are
reachable from the source. Let t t be the fence type of fi+l. Let (s t, t t) be a node such that s t _~ A~+l.
Let (u, w) denote the preimage of s t. Since the push function is monotonic and by existence of
the fence design which maps Ai onto Aj, there is an admitted reorientation cti+l by fi+l such that
(U -- O g i + l , W -- a/h-l) D Ai. Therefore, let (s,t) be a node such that (u - o ~ i + l , W - ogi_l_l) D 8 ~ Ai.
There is an edge from (s, t) to (s t, tt), and there is a path from the source to (s, t). Since s t _D Ai+l
is arbitrary, all (s t, t ~) with s t D_ Ai+l are reachable from the source. []

An important observation is that some graph edges are redundant if we are just interested in a fence
design of minimum length. Consider a node (s, t) and all its outgoing edges to nodes (s t = [ai, aj], t t)
for a fixed left endpoint ai and a fixed fence type t t. We show that only one of these outgoing edges
is sufficient. The following lemma is the key to this result.

Lemma 4. Let (s, t), (s', t') and (s", t') be nodes with s' : [ai, aj] and s" : [ai, ak] and let s' 3 s".
If there are edges from (s, t) to both (s', t') and (s", t'), then the edge from (s, t) to (s', t') can be
deleted without affecting the length of the shortest path in the graph.

Proof. Assume that 7- is a path from source to sink containing the edge ((s,t), (s~,tt)) and as-
sume ((s',tt),(sm, t " ) ) succeeds this edge in 7-. Because s t D stt, there must also be an edge
((s", t'), (s m, t"t)) in the graph. Hence, we can replace the edges ((s, t), (s t, t')) and ((s', t'), (s m, t"'))
in 7- by ((s, t), (s", t')) and ((s", t'), (s "t, tin)) without affecting the length of 7-. []

The repeated application of Lemma 4 to the graph (until no more edges can be deleted) leads to a
reduced graph in which every node has just one outgoing edge per set of nodes with intervals with
a common left endpoint and with a common fence type. The single edge from the initial graph that
remains after the repeated application of Lemma 4 is the one to the node corresponding to the shortest
interval. Since there are O(ms) = O(n) possible left endpoints and just two fence types, the number
of outgoing edges from one node is reduced to O(n). The total number of edges of the reduced graph
is therefore O(n3).

L e m m a 5. The reduced graph contains O(n 2) nodes and O(n 3) edges.

The (reduced) graph can be constructed in the following way. First we compute the push function
and store it in such a way that preimages can be found in O(1) time. For each node (s, t), left endpoint
ai, and fence type t ~, we must determine the shortest interval s t -- [a~, aj] such that an edge exists
between (s, t) and (s', t'). We can do this by a binary search on j. Since checking whether an edge
exists between a pair of nodes corresponds to computing the preimage of an interval (which can be
 R.-P Berretty et al. / Computational Geometry 10 (1998) 249-262 257

done in constant time), this binary search takes O(log n) time. As a similar binary search must be
performed for each combination of a node (s, t), a left endpoint ai, and a fence type t t, the total time
required to compute the graph edges is O(n 3 log n). A breadth-first search of the graph takes O(n 3)
time (see, e.g., [8]). This yields the following theorem.

Theorem 6. The computation of the optimal fence design for a polygonal part P with n vertices takes
O(n 3 log n) time.

Let T be a path in the graph from the source to the sink. Every edge of "r corresponds to a non-
empty angular interval of possible reorientations of the push direction. We simply pick the midpoint
of every such interval as the reorientation, and get a push plan which is a fence design. We can easily
compute the fence angles from the reorientation angles on the path, using the properties of the fence
framework [17].

3.2. Implementation

We implemented the described algorithm to test its behavior in practice. This turned out to be rather
easy, using only some basic geometric computations for the push function, and some standard graph
algorithms. The resulting code is very fast; it returned fence designs within a fraction of a second
for all parts we tried. All fence designs shown in this paper were generated by the program. Our
implementation offers the user the additional possibility of adding costs to graph edges. By doing
so, the user can prevent the algorithm from outputting certain types of fence designs. Assigning
high costs to edges between any pair of nodes of the same fence type t, for example, will cause
the algorithm to output a sequence of alternating (left and right) fences if such a sequence exists.
Alternating sequences are often preferred over sequences containing cascades of left (or fight fences),
as they generally allow for narrower conveyor belts (see Fig. 5). Different cost assignments can be
found to prevent, e.g., unwanted steep and shallow fences. The costs make it impossible to apply
Lemma 4 to reduce the graph size, as this may cause the removal of equally long or longer paths with
lower cost from the graph. The size of the resulting graph is therefore O(n4). Dijkstra's algorithm
(see, e.g., [8]) has been used to find the minimal cost path through the graph in time O(n4).

4. The existence of fence designs for asymmetric parts

In this section we concentrate on parts with push functions with a unique longest left environment
l(a) and a unique longest right environment r(b). We prove that for these asymmetric parts a fence
design always exists and has length O(n). In Section 5 we deal with parts that are not asymmetric.
Chen and Ierardi [7] use a sequence of equivalent basic actions to orient a polygonal part P with a
unique longest right environment r(a) of length o~. Each basic action consists of a reorientation of the
jaw by an angle of c~- #, with # > 0 such that c~- # > I (a')l for any equilibrium orientation a ~ ¢ a,
and a subsequent push. Note that a reorientation of the jaw by o~ - # corresponds to a change of the
orientation of the part by a - #. Every basic action puts the part into an equilibrium orientation. After
each basic action, the part is therefore in one of a finite number of equilibrium orientations. Let us
label the m equilibrium orientations a0, • • •, a ~ - i in order of decreasing angle starting from a0 = a.
After the first push, the part P can be in any of the equilibrium orientations a 0 , . . . , a ~ - l . Chen and
258 R.-P Berretty et al. / Computational Geomet~ 10 (1998) 249-262

(53
?
j- #
#-
Fig. 5. An optimal design of five fences, and a design of six alternating fences allowing for a narrower belt. Every line
segment emanating from the part represents a possible orientation of the part.

Ierardi show that every next basic action eliminates the last orientation in the sequence as possible
orientation of the part. Assume that P is in one of the orientations a 0 , . . . , ak, for some k ~> 1. The
key idea behind the proof is that a next basic action will cause P, when in orientation a0, to stay in
orientation a0 because a - # < I (a0)l = I (a)l, and, when in orientation ai for some 1 ~< i ~< k, to
move into some orientation aj with 0 ~< j ~< i - 1 because a - # > Ir(a~)l. Upon completion of the
basic action, the part will therefore be in one of the orientations a 0 , . . . , a k - l . As a consequence, a
total of m + 1 basic actions suffices to put P into orientation a0 = a. In other words, the sequence
(c~ - #)m+l is a valid push plan for P. In a similar manner, we could use reorientations by - ( / 3 - #),
and obtain the sequence (-/3 + #)re+l, where /3 is the length of the longest left environment. The
observation that ra = O(n) leads to the result of L e m m a 7.

L e m m a 7 [7]. A polygonal part P with n vertices can be oriented by N = O(n) pushes.

In order for the push plan ( a - #),~+1 or ( - / 3 + #)m+l to be a valid fence design, we have to show
that it satisfies the constraints formulated in Definition 2. We observe first of all that there can be no
more than three environments of length at least 7r/2, because the longest two left environments have
different lengths and the longest two right environments have different lengths. As a result, there is
at most one left environment of size at least 7r/2 or at most one right environment of size at least
7r/2. Assume without loss of generality that there is at most one right environment of size at least
7r/2. Although the length a of the longest fight environment r(a) can be at least 7r/2, the length a ~
of the second largest fight environment r(a t) must be smaller than 7r/2. If we now choose # such that
c~' < (x - # < min{c~, 7r/2}, then we get that c~ - # > [r(v)[ for all equilibrium orientations v # a.
 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262 259

In addition, we clearly have that c~ - # < 7r/2, which makes it easy to verify that (c~ - #)m+l is a
fence design.

Theorem 8. An asymmetric polygonal part P with n vertices can be oriented by a fence design of
length N = O(n).

5. Arbitrary parts

The considerations in Section 4 show that we can orient a part by a linear length fence design if
its push function has a unique longest left or right environment for which the second largest interval
has a length smaller than 7r/2. For asymmetric parts, there always exists such an environment. If we
deal with arbitrary parts, there can be several environments with the same size a, even with size
greater than 7r/2. In this section we show that for every polygonal part there is a fence design that
orients the part up to symmetry in its push function. We recall that ms denotes the number of stable
(equilibrium) orientations of P. We first show that we can orient P if the period of the push function
is 27r. The plans can actually be used to orient any part up to the period in its push function. The
method we use is similar to the method Chen and Ierardi introduced to generate push plans [7]. Recall
that a fence design is a push plan satisfying constraints on the reorientations of the jaw. We will
try to produce push plans that only use reorientations in either (0, 7r/2) or (-7r/2, 0), as such plans
clearly satisfy Definition 2. There are two problems with the implementation of the push plans of Chen
and Ierardi as a fence design. If there are several right environments with size greater than 7r/2, we
cannot orient the part. If there is no unique largest right environment, Chen and Ierardi apply their so
called 'stretching lemma' which in general uses any reorientation of the pushing jaw. The stretching
lemma shows that we can shift two possible orientations which both have a maximal left or right
environment closer to each other with one single push; in other words: we can break the symmetry if
there are multiple orientations with equally long maximal left or right environments. For a push plan
Lemma 7 remains valid [7,16]. For fences this is not necessarily the case. We can, however, reduce the
possible orientations of the part to those with maximal right environments or with right environments
of length greater than 7r/2 by an alternating sequence of jaw applications and jaw reorientations by
an angle min{a - #, :r/2 - #} (a and # as in Section 4; no right environment shorter than 7r/2 is
longer than 7r/2 - #). (We can similarly reduce the possible orientations to orientations with such
left environments.) As observed, for arbitrary parts, the number of possible orientations can be larger
than one. We have to use more sophisticated fence designs to further reduce the number of possible
orientations.
We start with some definitions which we use throughout the rest of this section. Let c~ again be
the length of the longest right environment and let /3 be the length of the longest left environment.
Furthermore, let .A = a o , . . . , am~-I be the cyclic sequence of stable equilibria, cut at some arbitrary
orientation and ordered by increasing angle. The sequence .,4 is said to have right cycle d if and only
if Ir(ai)l = Ir(ai+d)l for all 0 ~< i < ms. (Indexing is modulo ms.) Similarly, the sequence fit has left
cycle d if and only if II(ai)l = II(ai+d)l for all 0 ~ i < ms. We denote by 7E the set of orientations
in A with right environments of length c~, or length greater than or equal to 7r/2. We define the right
measure M n of an interval Iv, w] of orientations by
M~([v,w]) = [{a C ~ l v ~< a < w}l"
260 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262

In a similar manner, we can define a set E of orientations with left environments of length/3, and a
left measure M e . We let # > 0 be a small constant such that ~ - # and c~ + # are both smaller than
7r/2 but larger than any environment of length less than 7r/2. In addition, the constant # is smaller
than the length of any environment. We recall that polygonal parts without meta-stable edges have
push functions without left and fight environments of zero length.
Our push plans for arbitrary parts consist of three types of basic building blocks. These building
blocks are referred to as MOVE, SHIFT and REDUCE.
• Suppose that [v, w] with v, w E .A is the current interval of possible orientations. Then, the push
plan (min(a, 7r/2) - #),~,s MOVEs the interval Iv, w] into an interval Iv~, w I] with v ~, w ~ E 7-¢ of equal
right measure.
• Suppose that [v = ai, w = aj], v, w C ..4, is the current interval of possible orientations. Then, the
push plan (Ir(v)l +/~) SHIFTs the interval [v, w] into an interval [v~, w I] with v ~ = ai+l, w t E A.
If v, w E 7~ then w ~ = aj+l of and the right measure of [v~, w I] equals the right measure of [v, w].
Notice that in that case a SHIFT followed by a MOVE maps [v, w] into an interval [v", w"] with
v", w" E 7¢ and v ~ ¢ v, w' ¢ w (provided that 7¢ has at least two elements) of equal right measure.
• Suppose that [v, w] with v, w E 7~ is the current interval of possible orientations. We want to define
an operation which REDUCES an interval [v, w] to some interval [v t, w ~] with v ~, w ~ E .,4 of smaller
measure. The REDUCE exploits specific asymmetries that are present in the push function to achieve
the reduction of the measure. Different classes of push functions lead to different REDUCEs.
The objective is to use these building blocks in a push plan that is guaranteed to result in an interval
of possible orientations of measure zero.
According to the "stretching lemma" of Chen and Ierardi [7], any interval [v, w], v ¢ w, of possible
orientations can be mapped onto a shorter interval of possible orientations [v~, w ~] by a single push. An
additional push will then map [v~, w ~] onto an interval Iv", w"] satisfying MTz([v", w"]) < M~([v, w]).
The problem in applying these ideas in fence design is that the two required reorientations of the push
direction may not be achievable by a sequence of fences. We will use the SHIFT and MOVE plans
to overcome this problem. We classify the push functions, based on the left and fight cycle of the
stable equilibria, and the sizes of the environments. The implementation of the REDUCE is the main
difference between the distinct classes of push functions. We distinguish the following classes of push
functions.
(1) Either the left or the right cycle is ms, and no left or right environment is longer than 7r/2 in that
cycle.
(2) Both the left and the fight cycle are smaller than ms.
(3) Both the left and the right cycle are m~ and there is more than one environment of length greater
than 7r/2.
We will only globally describe the approach for each of the three cases. The detailed proof is lengthy
and rather involved. Interested readers can find the detailed proof in [3].
Let us first concentrate on push functions in the first and second class. Suppose that [v, w] with
v, w E 7~ is the current interval of possible orientations. Let v r and w ~ be the smallest orientation in
7~ larger than v and w, respectively. If the sequence of right environments of orientations between
v and v ~ differs from the the sequence of right environments between w and w', then there exists a
simple strategy that maps [v, w] either onto [v~, u] with u E .A \ ~ and w < u < w I or onto [u, w ~]
with u E ..4 \ 7~ and v < u < v ~. Moreover, it can be shown that any interval [v, w] with v, w E
can be transformed - by means of SHIFT and MOVE plans - into a different interval Iv", w ' ] with
 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262 261

v", w" E ~ of equal measure, such that the simple strategy is guaranteed to map [v", w"] onto Ivt, u],
with u E ~4 \ ~ and w < u < w ~, and where v ~ and w ~ are the smallest orientations in R larger than
v and w, respectively. A subsequent reorientation by c~ + # followed by a push will eliminate v t as a
possible orientation of the part without adding new possible orientations from R. As a consequence,
the measure of the resulting interval of possible orientations is smaller than MT~([v', u]). For push
functions from the first class, this strategy (or its equivalent using left environments) suffices to reduce
the interval of possible orientations to an interval of measure zero. The reorientations of the push
direction in the entire scheme are restricted to (0, 7r/2) or (-7r/2, 0), which makes the sequence
of pushes a valid fence design. If the left and right cycle are both smaller than ms, then we must
eventually switch our attention from the right environments to left environments to break the rotational
symmetry of the right environments (or vice versa). It turns out that such a switch can be accomplished
without violating the reorientation constraints for fence designs.
The third class of push functions requires some modifications to the MOVE, SHIFT and REDUCE
framework. There are, however, at most three environments of length greater than 7r/2, which makes
it possible to treat the different cases one by one, and provide dedicated push plans which use both
left and right fences. These dedicated push plans satisfy the reorientation constraints and are therefore
valid fence designs.
Theorem 9 summarizes the result of this section.

Theorem 9. Any polygonal part can be oriented up to rotational symmetry by a fence design.

A consequence of Theorem 9 is that the algorithm for computing fence designs presented in Sec-
tion 3.1 always outputs a fence design. Since the graph used in the algorithm has O(n 2) nodes, the
length of the shortest path is O(n2).

Theorem 10. Any polygonal part with n vertices can be oriented up to rotational symmetry by a fence
design of length O(n2). The optimal fence design can be computed in O(n 3 logn) time.

6. Conclusion

In this paper we investigated the problem of sensorless part orientation by sequences of pushes.
We showed that any polygonal part can be oriented by a sequence of fences placed along a conveyor
belt. We presented the first polynomial-time algorithm for computing the shortest fence design for any
given polygonal part. The algorithm is easy to implement and runs in time O(n 3 log n). The structure
of the algorithm yields an O(n 2) bound on the length of the shortest fence design. We showed that
for asymmetric parts the length is actually bounded by O(n). It remains an open problem whether an
O(n) bound exists for parts that are not asymmetric.
Although pathological polygons can be constructed that lead to push plans and fence designs of
length £2(n), it turns out that the length of most plans remains far below the worst-case length. In [16],
van der Stappen et al. deduced a bound on the plan length that depends only on the shape of the part
under consideration. It turns out that a small number of actions is sufficient for most parts. The analysis
also applies to curved parts, providing the first complexity bound for non-polygonal parts. The results
generalize to fence designs for parts with acyclic left and right environments. It remains an open
question whether this bound can be transferred to arbitrary parts.
262 R.-P. Berretty et al. / Computational Geometry 10 (1998) 249-262

Acknowledgements

We thank Matt Mason and Kevin Lynch for several interesting discussions and Jeff Wiegley and
Anil Rao for useful feedback.

References

[1] S. Akella, W. Huang, K.M. Lynch, M.T. Mason, Sensorless parts feeding with a one joint robot, in:
J.-P. Laumond, M. Overmars (Eds.), Algorithms for Robotic Motion and Manipulation, A.K. Peters, 1996,
pp. 229-238.
[2] S. Akella, M.T. Mason, Posing polygonal objects in the plane by pushing, in: IEEE International Conference
on Robotics and Automation, Nice, 1992, pp. 2255-2268.
[3] R.-P. Berretty, K. Goldberg, M. Overmars, A.E van der Stappen, Computing fence designs for orienting
parts, Technical Report, UU-CS-1997-41, Department of Computer Science, Utrecht University, 1997.
[4] K.-E B6hringer, V. Bhatt, K.Y. Goldberg, Sensorless manipulation using transverse vibrations of a plate, in:
Proceedings IEEE International Conference on Robotics and Automation, Nagoya, Japan, 1995, pp. 1989-
1996.
[5] K.-F. B6hringer, B.R. Donald, N.C. MacDonald, Upper and lower bounds for programmable vector fields
with applications to mems and vibratory plate part feeders, in: J.-P. Laumond, M. Overmars (Eds.),
Algorithms for Robotic Motion and Manipulation, A.K. Peters, 1996, pp. 255-276.
[6] M. Brokowski, M.A. Peshkin, K. Goldberg, Optimal curved fences for part alignment on a belt, ASME
Trans. Mech. Design 117 (March 1995).
[7] Y.-B. Chen, D.J. Ierardi, The complexity of oblivious plans for orienting and distinguishing polygonal parts,
Algorithmica 14 (1995) 367-397.
[8] T.H. Cormen, C.E. Leiserson, R.L. Rivest, Introduction to Algorithms, The MIT Press, Cambridge, MA,
1990.
[9] M.A. Erdmann, M.T. Mason, An exploration of sensorless manipulation, IEEE J. Robotics Automation 4
(1988) 367-379.
[10] K. Goldberg, Orienting polygonal parts without sensors, Algorithmica 10 (2) (1993) 201-225.
[11] K.M. Lynch, M.T. Mason, Stable pushing: Mechanics, controllability, and planning, Internat. J. Robotics
Res. 6 (15) (1996) 533-556.
[12] M. Mason, Manipulator grasping and pushing operations, Ph.D. Thesis, MIT, 1982.
[13] B.K. Natarajan, An algorithmic approach to the automated design of parts orienters, in: IEEE Annual
Symposium on Foundations of Computer Science, 1986, pp. 132-142.
[14] M.A. Peshkin, A.C. Sanderson, The motion of a pushed sliding workpiece, IEEE J. Robotics Automation
4 (6) (1988) 569-598.
[15] M.A. Peshkin, A.C. Sanderson, Planning robotic manipulation strategies for workpieces that slide, IEEE J.
Robotics Automation 4 (5) (1988) 524-531.
[ 16] A.E van der Stappen, K. Goldberg, M. Overmars, Geometric eccentricity and the complexity of manipulation
plans, Technical Report UU-CS-1996-49, Department of Computer Science, Utrecht University, 1996. To
appear in Algorithmica.
[17] J. Wiegley, K. Goldberg, M. Peshkin, M. Brokowski, A complete algorithm for designing passive fences to
orient parts, Assembly Automation 17 (2) (1997) 129-136.