Stable bin packing of non-convex 3D objects with a robot manipulator

12/10/2018 ∙ by Fan Wang, et al. ∙ Duke University 0

Recent progress in the field of robotic manipulation has generated interest in fully automatic object packing in warehouses. This paper proposes a formulation of the packing problem that is tailored to the automated warehousing domain. Besides minimizing waste space inside a container, the problem requires stability of the object pile during packing and the feasibility of the robot motion executing the placement plans. To address this problem, a set of constraints are formulated, and a constructive packing pipeline is proposed to solve for these constraints. The pipeline is able to pack geometrically complex, non-convex objects with stability while satisfying robot constraints. In particular, a new 3D positioning heuristic called Heightmap-Minimization heuristic is proposed, and heightmaps are used to speed up the search. Experimental evaluation of the method is conducted with a realistic physical simulator on a dataset of scanned real-world items, demonstrating stable and high-quality packing plans compared with other 3D packing methods.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 4

page 6

page 7

page 8

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Recent years have seen increasing interest in warehouse automation, including fully automatic robot packing, supported by the technical progress made in the field of robotic manipulation, as demonstrated by recent competitions like the Amazon Robotics Challenge. The current state of practice in fulfillment centers leaves the responsibility of container selection and packing to human worker intuition. Due to demanding schedules, workers cannot employ much foresight in the packing process and are reluctant to re-pack. This commonly results in grossly oversized containers that generate waste and high shipping costs (Fig. 1). Better containers and packing plans could be chosen using automated algorithms, whether packing is accomplished by humans or robots.

Problems that involve the placement of objects within a container or a set of containers are generally referred to as the cutting and packing problems. Most existing packing algorithms apply to idealized scenarios, such as rectilinear objects and floating objects not subject to the force of gravity. To perform automatic packing in warehouses using a pre-computed packing plan, several real-world issues need to be addressed, such as the feasibility of the packing under the force of gravity, and kinematics and clearance issues for the robot. If stability is not considered, the pile may shift during execution, and therefore subsequent placements are unlikely to be executed as planned. If kinematics and clearance are not considered, the robot may be asked to perform infeasible motions (e.g., grip an item from underneath, bring an item to a target through another interlocked item, or pass through the container wall).

Fig. 1: Examples of poor space utilization in shipping boxes.

For a packing plan to be feasible with a robot manipulator, a comprehensive set of constraints need to be formulated.

In addition to the two standard packing constraints:

  1. Noninterference. Each object is collision free,

  2. Containment. All objects are placed within the internal space of the container,

we introduce the following constraints necessary for a robot-packable plan:

  1. Stability. Each object is stable against previously packed objects and the bin itself, and

  2. Manipulation feasibility. A feasible robot motion exists to load the object into the target placement. The robot must obey kinematic constraints, grasp constraints, and collision constraints during this motion.

In the following sections, we refer to constraints 1 and 2 as the non-overlap constraints, and constraints 1-4 as all constraints, or the robot-packable constraints.

While the application of robot-packable constraints is independent of the particular packing problem addressed, this paper focuses on the problem of offline packing of 3D irregular shapes into a single container, which is very relevant to an automated packing scenario in a fulfillment center, under robot-packable constraints.

To solve for the problem, we present the following main contributions:

  1. A polynomial time constructive algorithm to implement a resolution-complete search amongst feasible object placements, under robot-packable constraints.

  2. A 3D positioning heuristic named Heightmap-Minimization (HM) that minimizes the volume increase of the object pile as observed from the loading direction.

  3. A fast prioritized search scheme that first searches for robot-packable placement in a three-dimensional space that likely contains a solution, and falls back to search in a five-dimensional space.

Our algorithm and others in comparison are tested in a realistic physics simulator, by packing large quantities of random item sets using high-quality, real-world object scannings. With item sizes of 3-5 objects (e.g., a common Amazon order size), the success rate is 100% for finding and executing packing plans using small Amazon order boxes. Large number of items are also packed in stress tests, in these tests, 80% of the placement plans were successfully executed in the physics simulator, which is significantly better than the 17% success rate from a standard packing solver under the same testing condition. Empirical results also show that the new Heightmap-Minimization heuristic finds more placements than existing heuristics, both under non-overlapping constraints and robot-packable constraints.

Ii Related Work

Popular variations of the cutting and packing problem include the bin and strip packing problem, the knapsack problem, the container loading problem, and others. Most existing research on cutting and packing handles floating 2D and 3D rectilinear objects under the non-overlapping constraints. Under some settings, such problems can be formulated and solved to optimally using the exact algorithms. One example of these state-of-the-art exact algorithms is the solution to the 3D bin packing problem using branch and bound, proposed by Martello et al. [1, 2], whose work is further extended by many including Boef et al. [3] and Crainic et al. [4]. The exact algorithms, although capable of finding the optimal solution if infinite time is spent, are strongly NP-hard [5] and do not guarantee optimal results within a reasonable amount of time, especially when a large number of instances are involved [2]. Therefore, heuristic methods and metaheuristic approaches have been developed over the years, such as the popular “Bottom-Left (BL)” heuristic [6] and the Best-Fit-Decreasing heuristic [7].

On the other hand, irregular shape packing, often referred to as nesting, is a more recent variant of the cutting and packing problem. With non-rectilinear geometries, the search space is infinite, with few guidelines available to narrow it down to finite options. Metaheuristics such as Simulated Annealing (SA) [8, 9, 10] and Guided Local Search (GLS) [11, 12, 13, 14, 15] are the most popular tools for solving a nesting problem. These methods commonly start with an initial placement and iteratively improve the placement by moving the pieces in the neighborhood while minimizing an objective function (e.g., overlap in the system). In addition to metaheuristic methods, recent work has also proposed constructive positioning heuristics for 3D irregular objects, such as Deepest-Bottom-Left-Fill (DBLF), which places items in the deepest, bottom-most, left-most position; and Maximum Touching Area (MTA), which places an item in a position that maximizes the total contact area of its faces with the faces of other items [16].

Some research has taken additional constraints into consideration during packing. Egeblad et al., for example, use a two-stage GLS packing algorithm that, in the first stage, optimizes for the center of gravity and inertia of the pile and, in the second stage, minimizes overlap in the system. The optimization for different constraints is performed by adjusting the contribution of constraints dynamically in an augmented objective function [12]; Liu et al. propose a constructive method called HAPE3D that packs irregular 3D shapes using a Minimum-Total-Potential-Energy heuristic [10]. This method performs a grid search in a 5D search space (e.g., , , , X, Y) for the lowest gravitational center height z for each shape at the time of placement, and can be hybridized with metaheuristic SA to search for packing permutations that lead to lower total potential energy in the system. However, the proposed method is only a heuristic, and does not verify the stability of each placement. In contrast from these works, our method enforces stability explicitly using constraints.

We also know of one packing work that takes into account robot manipulation feasibility [3], in which the author proposes a variant of the orthogonal 3D box packing scheme such that no prior packed box is in front of, to the right of, or above the current placing box, to avoid possible collision with a vacuum gripper. Although this placing rule prevents a robot from colliding with boxes whose dimensions are much larger than the vacuum gripper, it cannot be generalized to other gripper geometries (e.g., parallel jaw gripper) and does not consider other aspects of robot feasibility such as kinematic constraints and graspability constraints.

To the best or our knowledge, ours is the first packing work to solve for stability and robot-feasibility constraints simultaneously. Moreover, these constraints can be solved for arbitrary shaped 3D objects that are complex and non-convex.

Iii Problem Definition

We address the problem of offline bin packing of 3D irregular shapes using a single box while ensuring the stability of each packed item and feasibility of the placement with a robot gripper.

Specifically, for a set geometries where , let donate the free space volume of the container and as the boundary of the free space. Let denote the space occupied by item  when the geometry is transformed by . The problem is to find a placement sequence of and transforms such that each placement satisfies non-overlapping and containment constraints with geometries placed prior:

(1)
(2)

and for each , stability constraints:

(3)

and manipulation feasibility constraints:

(4)

It is important to note that both stability and manipulation feasibility constraints must be satisfied for every intermediate arrangement of objects, not just the final arrangement.

Iii-a Stability checking

Stability is defined as the condition in which all placed items are in static equilibrium under gravity and frictional contact forces. We model the stack using point contacts with a Coulomb friction model with known coefficient of static friction. Let the set of contact points be denoted as , which have normals , and friction coefficients . For each contact , let the two bodies in contact be denoted and . Let denote the contact forces, with the convention that is applied to and the negative is applied to . We also define as the mass of object , and as its COM. We take the convention that either or indicates contact with the container wall.

The object pile is in static equilibrium if for , there are a set of forces that satisfy the following conditions.

Force balance:

(5)

Torque balance:

(6)

Force validity:

(7)
(8)

for all , where is the tangential component (i.e., frictional force) of .

For a given arrangement of objects, an approximate set of contact points is obtained by slightly scaling geometries and determining the set of geometric features that overlap when scaled. We also perform a clustering step in which we merge all contact points within a grid size of 1 cm, which reduces the number of contacts to a more manageable number. Also, a pyramidal approximation for the friction cone is used, and the conditions above are formulated as a linear programming problem over

, Our implementation uses the convex programming solver CVXPY to solve for a feasible set of forces [17]. If no such forces can be found, the arrangement is considered unstable.

Iii-B Manipulation feasibility

This constraint checks feasibility of a packing pose when executed by a robot manipulator. This requires that the object be graspable from its initial pose and can be packed in the desired pose via a continuous motion, without colliding with environmental obstacles.

In our system we limit ourselves to existence of a feasible top-down placement trajectory within the grasp constraints. Robots performing pick and place (e.g., box packing) in the industry commonly use vertical motion that keeps the gripper opening parallel to the container [3]. On this basis, we assume the robot gripper to perform top-down movement only when within the free space of the container. We also assume the existence of a grasp generator that produces some number of candidate end effector transforms, specified relative to an object’s geometry that may be used to grasp the object. The pseudo-code for this procedure is given in Alg. 1.

input : Desired placed geometry and a set of grasp candidates
output : Whether a feasible top-down loading path exists
1 for  do
2       Compute top-down end effector path interpolating from an elevated pose to a final pose ;
3       for  do
4             IKSolvable () inJointLimits() collisionFree();
5             if  then
6                  Continue with Line 1
7             end if
8            
9       end for
10      return True
11 end for
return False
Algorithm 1 isManipFeasible

Iv Pipeline for Robot-packable Planning

We develop a constructive packing pipeline to solve for the set of robot-packable constraints proposed. Our algorithm accepts an item set, a container dimension, a constructive positioning heuristic, and/or a packing sequence, to produce packing plans. The pipeline packs each item to its optimized feasible pose in sequential order, without backtracking.

Our pipeline primarily consists of 4 components, namely:

  1. Placement sequence

  2. Positioning heuristic

  3. Stability check

  4. Manipulation feasibility check

The pipeline implements a polynomial time resolution-complete search amongst feasible object placements under robot-packable constraints. Alternatively, the pipeline can produce results under a different level of constraints by enabling and disabling the stability and manipulation feasibility components that are implemented as separable processes.

The pipeline starts with a sequencing heuristic to sort all items in a tentative placement ordering and allocates them individually into the container in this sequence. For each object at the time of the allocation, a set of candidate transforms satisfying non-overlap constraints are generated given the container and object already placed. The candidate transforms are scored and ranked based on the positioning heuristic used. With no additional constraint required, the pipeline returns the best scored candidate transform. With additional constraints enabled, the ranked candidates go through specified constraint checks until a solution satisfying all required constraints is returned.

Iv-a Placement sequence

Our algorithm allows user-specified packing sequences. If a sequence is not provided, we use a non-increasing bounding box volume heuristic to generate a tentative sequence, which is subject to adjustment if a solution cannot be found in its current ordering.

The non-increasing bounding box volume heuristic is equivalent to the non-increasing volume heuristic when applied on rectilinear objects. The latter is known to lead to the fastest convergence of the branch-and-bound algorithms [2] and the good performance of the Best-Fit decreasing heuristics with rectangular-shaped objects. For 3D irregular shapes, bounding box volume is chosen instead of the exact volume to increase robustness against incomplete geometries and geometries that contain large concavity.

Iv-B Positioning Heuristic

For a given item, a positioning heuristic (e.g., placement rule) identifies a free pose inside the container (or placement of the item) that is most preferred according to a specific criterion. Our pipeline accepts arbitrary positioning heuristics, but instead of applying the heuristic to obtain one optimal placement for each item, we use the score formulated from the positioning heuristic to rank candidate placements.

The candidate placements are obtained with a prioritized search among a discretized set of object poses. Instead of searching in the 6D space of SE(3), the algorithm first performs a grid search in a 3D space that likely contains stable solutions for horizontal surfaces. This addresses the common case of packing on the first layer and on horizontal objects like boxes. The three-dimensional search space for a geometry is defined as follows: The rolls and pitches of are restricted to be a set of planar-stable orientations, which are a set of stable resting orientations of on a planar surface. We use the method of Goldberg et al. [18], which uses the convex hull of the object, and also computes the likelihood of landing in a given orientation if the object is dropped onto a plane randomly.

Our algorithm for finding a feasible placement of one object, given a set of rolls and pitches, is summarized in Alg  2. The height Z of the placement is analytically determined as the lowest legal placement for the oriented item at the given horizontal translation. A grid search is then performed for yaw, X and Y at a granularity that transforms within the container interior. If no robot-packable solution exists in this three-dimensional search space, the algorithm falls back to search in a 5D space where a grid search is performed for rolls and pitches as well. This fallback procedure is discussed in more detail in later sections.

2D heightmaps are used to accelerate the computation of the lowest collision-free Z to an efficient 2D matrix manipulation. Three heightmaps are computed: 1) a top-down heightmap of the container and objects already placed (Fig. 2), 2) a top-down heightmap of the object to be placed, measured relative to the lowest point at the object’s given orientation, and 3) a bottom-up heightmap of the object to be placed, again measured relative to the lowest point. The container heightmap is obtained once at the beginning of object placement search, and an object heightmap is computed once for each distinct orientation in search. The resolution of each heightmap is set equal to the resolution of search in the X, Y plane, and the object heightmaps are sized to the object’s axis-aligned bounding box. Raycasting is used to build these heightmaps, and rays that do not intersect with the object geometry are given height 0 in and in .

Given an object orientation and X,Y location, we calculate the lowest collision-free Z as follows:

(9)

where are the pixel coordinates of , and to be the dimensions of .

Fig. 2: Terrain heightmap of 4 items.
input : Item geometry , container , rolls and pitches
output : All legal candidate transforms
1 for  do
2       for  do
3             Let ;
4             Discretize legal horizontal translations of into grid ;
5             for  in  do
6                   Find the lowest collision free placement at translation ;
7                   Let be rigid transform with rotation and translation ;
8                   if  lies within  then
9                         Add to
10                   end if
11                  
12             end for
13            
14       end for
15      
16 end for
return
Algorithm 2 3DGridSearch

Once all legal candidate transforms are obtained, they are scored by a scoring function formulated from a positioning heuristic. For example, the Deepest-Bottom-Left-First heuristic can be formulated as the score:

(10)

where c is a small constant.

The candidates are then ranked by score (lower is better). If only non-overlap constraints are required, the placement candidate with the lowest score is returned. If additional constraints are specified, the ranked candidates will be checked for the additional constraints until a candidate satisfying all constraints is returned.

After an object has been placed, we use a heightmap update subroutine that augments with the new object. This subroutine is also used in our heightmap minimization heuristic. Given a pose of the object to be packed, and the top heightmap at the given orientation, we calculate an updated heightmap that contains the placed object as follows. For all , , we let

(11)

if , and

(12)

otherwise.

Iv-C Pipeline summary and fall back procedures

A packing attempt for a single item is summarized in Alg 3, where a set of rolls and pitches are given as input. It sorts the candidate feasible placements by the heuristic, and finds the first placement that satisfies stability and robot-packability.

The overall pipeline for packing multiple objects is given in Alg 4. Given a heuristic packing sequence (non-increasing bounding-box volume), it calls Alg. 3 for each item with the set of planar-stable rolls and pitches. This first stage finds placements for most objects in typical cases. For the remaining unpacked items , the algorithm activates the fallback procedure.

The fallback procedure beginning in line 15 examines each unpacked item, and attempts to perturb the set of planar stable orientations to find an orientation that is packable. It starts iterating over rolls and pitches until a solution is found, and if no solution is found the algorithm terminates with failure. (Note that the first iteration begins by repacking the same item in the planar stable orientations, which may succeed now that the state of the bin has changed.)

input : item geometry , container , pitches and yaws , sequence of the packed items , transforms of the packed items
output : Transform or None
1 3DGridSearch();
2 Score each in based on heuristic used;
3 for up to lowest values of in  do
4       isStable();
5       if  then
6            continue
7       end if
8      Obtain grasp pose candidates compatible with ;
9       = isManipFeasible(, );
10       if  then
11            return
12       end if
13      
14 end for
return None
Algorithm 3 packOneItem
input : Item geometries , container , initial packing sequence
output : Transforms and final packing sequence , or None
1 Initialize to empty lists;
2 for  do
3       Get planar-stable rolls and pitches for

with the top n highest quasi-static probabilities

;
4       Add to ;
5      
6 end for
7for  do
8       packOneItem(, , , , );
9       if  then
10            Add to ;
11             Add to ;
12       else
13            Add to ;
14       end if
15      
16 end for
17for  do
18       Let be the planar-stable orientations in ;
19       for  do
20            for  do
21                   ;
22                   packOneItem(, , , , );
23                   if  then
24                         Add to ;
25                         Add to ;
26                         continue with Line 15
27                   end if
28                  
29             end for
30            
31       end for
32      return ‘‘no solution’’
33 end for
return ()
Algorithm 4 Robot-feasible packing with fall back procedures

V Heightmap-Minimization Heuristic

The performance and solution quality of a multi-dimensional packing problem is highly susceptible to the item-positioning rule [19]. However, existing positioning heuristics for 3D objects are scarce, and most of them are adapted directly from positioning rules developed for 2D packing problems, in which many were designed for packing rectangles only. It is known that naive generalization of heuristics from 2D to 3D leads to poor space utilization in the container [20, 4].

Furthermore, multi-layer positioning rules for irregular shapes, particularly non-convex shapes, have not been sufficiently addressed in the previous literature. To address these shortcomings, we propose a novel positioning heuristic called the Heightmap-Minimization (HM) heuristic, which favors item placement that results in the smallest occupied volume in the container as observed from the loading direction.

Specifically, the score of a placement using HM heuristic is computed as follows. Given the candidate transform , compute a tentative container heightmap using the update routine described in Sec. IV-B. Suppose its shape is . The score for the placement using the HM heuristic is:

(13)

where is a small constant.

HM favors positions and orientations that result in good space utilization (Fig 3). Since hole fillings are expensive, and not allowed with heightmap representations, HM has the advantage of minimizing wasted space given the objects already placed in the container.

Fig. 3: Packing a large box after three bowls using HM and DBLF heuristics. The HM stacks the bowls while the DBLF heuristics spreads them out, wasting space. Note that HM automatically selects the face-up orientation because it minimizes unused space, while the DBLF finds the same orientation to minimize center of gravity.

HM also favors stable placements (Fig 4) due to the maximum matching of geometry with the terrain underneath. Because the bottom of the object is encouraged to match the shape of the supporting terrain, the generated placements are generally more stable than with other heuristics.

Fig. 4: Most position-based heuristics ignore the wasted space underneath when an object is placed, such as DBLF. The HM heuristic, while maximizing unused space, inherently minimizes the wasted space between the terrain and the item to be placed and, therefore, likely increases contact areas and results in a more stable packing.

Vi Experiment

We tested our algorithm using several distributions of item sets and heuristic choices. The resulting placements were then checked for feasibility in a physics simulator.

The 3D object models used are scannings of real-world objects drawn from the YCB object set[21] and the APC 2015 object set[22]. 94 total items in the categories of toys, food, home supplies, etc. are used. The polygon meshes of each object on average contain 10,243 vertices.

Experiments are conducted on Amazon Web Services instance type m5.12xlarge. All computation times are measured on a single thread. Parameters used in the experiment are: heuristic constant ; heightmap resolution 0.002m; step size in both X and Y 0.01m; in range ; friction coefficient . Contact points are obtained using the exact geometry with a scale factor of 1.03. The top 4 planar-stable rolls and pitches with the highest quasi-static probabilities are used. Up to 100 legal placement candidates are checked for stability and manipulation feasibility.

Vi-a Small Order Packing

To evaluate our algorithm for everyday packing tasks seen in automated warehouses, we performed a small order packing test simulating problem settings in an Amazon warehouse. Per communication with personnel at Amazon, 3-5 items are a standard order size. We also selected the 5 container sizes used in the Amazon Robotics Challenge 2017 [23].

We generated 1000 item sets consisting of 3-5 models randomly selected from the APC and YCB datasets. The tested algorithm uses the HM heuristic and is required to obey all robot-packable constraints. The algorithm tries to find a feasible solution using the smallest container first, and if this step fails, the algorithm moves to the second smallest container and repeats the process until either a solution is found or all available containers are exhausted. Using this process, solutions are found for 100% of all orders using on average 8.54 s per order (Fig. 5).

Fig. 5: Examples of packing plans for item sets of size 3–5.

Vi-B Comparisons on Large Item Sets

Next, we compare how our method performs in more complex stress tests of item sets of size 10. A container of size cm is chosen, which is big enough to fit relatively large items while being small enough so that objects need to be packed in many layers to fit in the box. Item sets are randomly generated, and we attempt to find a non-overlapping placement for the set within the container using all of our tested methods. (Robot-packability is not guaranteed.) This continues until 1000 feasible item sets are generated.

We compare our HM heuristic against the DBLF and MTA heuristics [16], as well as an implementation of a guided local search (GLS) method as described by Egeblad et al. [12]. The fast intersection area theorem, as described in Egeblad’s paper, was not implemented. Therefore, for the fairness of the comparison, GLS was run with 5 random restarts, and each restart was terminated after 300 s if a solution could not be obtained. Fig. 6 shows some example packing plans, and Table I reports the percentage of solutions found and the average computation time for each set. With non-overlap constraints only, HM and DBLF have comparable high success rates and low running time, with HM finding solutions in 1.5% more cases, while MTA and GLS are not as competitive. When robot-packable constraints are enabled, HM and DBLF still lead the percentage of solutions found (HM has a 1% advantage over DBLF), both finding 96% solutions, that is a 10% edge over the third place MTA.

Fig. 6: Examples of packing plans for item sets of size 10.

The success rate for GLS under robot-packable constraints is not reported as such constraints were not implemented in the previous GLS works. Generally speaking, implementation of robot-packable constraints on GLS methods can be challenging due to two reasons: 1) Stability and feasibility constraint cannot easily be implemented in the objective function, and 2) GLS is not sequential so that there is no inherent packing sequence.

HM DBLF [16] MTA [16] GLS [24]
Success, non-overlap (%) 99.9 98.4 88.9 78.9
Time, non-overlap (s) 15.7 14.2 14.1 502
Success, all constraints (%) 97.1 96.3 86.3
Time, all constraints (s) 34.9 50.1 95.4

TABLE I: Comparing planning techniques on 10-item orders with and without robot-packability constraints

Empirically, Heightmap-Minimization finds more solutions than any other method in comparison, under all degrees of constraint. With a non-overlapping constraint only, HM finds 99.9% of all feasible solutions, leading the 2nd place DBLF heuristic by 1.5%. After adding manipulation feasibility and stability constraints, each technique drops in success rate by a few percent, but HM still leads the 2nd place DBLF by 1%.

With all constraints, HM has a mean average running time of 34.9 s, which is at least 30% shorter than other heuristics used. The minimum/maximum running time is 14.58/403.68 s. This indicates that the highest ranked placements with HM heuristic are more likely to be stable placements than either of the other two heuristics.

In addition, only 3.2% of the items are packed with the fallback procedure. Of these, 51% were packed by adjusting the packing sequence of the item, and the other 49% were packed by performing the search in 5D. These statistics indicate that the 3D space searched is indeed highly likely to contain robot-packable solutions, and the prioritized search in 3D space is significantly more efficient than always searching in 5D. Our other tests indicate that simply performing the 5D search has an average running time of 522  s, which is 15 times slower than the prioritized search.

Vi-C Executing Complex Packing Plans

Finally, we test open-loop execution feasibility of packing plans in the Klamp’t robot physics simulator [25]. In the simulation, the robot places one item after another using a top-down loading direction. The plan is considered a success if: 1) when placing each object to its planned transform, the robot and the object do not collide with items placed prior, and 2) all items are contained within the free space of the container when placement is complete.

The robot used in the simulation is a Staubli TX90 robot, equipped with a rectangular vacuum gripper of 30 cm length and 2 cm diameter. We assume the vacuum gripper can grasp an object in its destination orientation at the center of the object’s top surface, while the gripper axis is aligned with the Z axis. The robot executes top-down loading motions, ending in a pose where the item is elevated by 1cm from its planned transform; therefore there is an expected 1 cm drop. We allow 20 s for the items to settle before the next item is placed.

In the small item set case (3-5 items), 100% of plans are successfully executed in the physics simulator, with an average drop of 1.08 cm and 0.49 cm horizontal displacement when executed in the physics simulator.

Table II describes results in the 10 item case. 768 out of 971 (80%) of robot-packable plans obtained with HM heuristic were executed successfully according to our success criteria. Using the non-overlap constraints only, the execution success rate was only 17%. The shifts and drops of the item in the simulation are also logged. Under all constraints, the average drop of an item is 1.36 cm in the container (due to margins in the Z direction and extra 1cm lifted by the robot), and the horizontal shifts on average are 0.5 cm. Our method has a smaller displacement, which indicates greater stability, and a smaller drop, which reduces possible damage by falling from a height in real practice.

Success (%) Drop (cm) Horiz. Shift (cm)
Non-overlap constraint 17.11 1.95 1.29
All constraint 79.1 1.36 0.50

TABLE II: Execution success rates in simulation, 10-item orders

The 20% of failure cases are caused by an object falling out of its desired placement, which prevents subsequent items from being packed. The stability checker may be too optimistic, especially for intrinsically unstable objects like balls. Moreover, the impact of dropping an object could shift supporting objects. An illustration is shown in Fig. 7.

Fig. 7: A typical execution failure case. The left three frames show a ball rolling out of its desired position. This prevents the subsequent placement of the drill, as shown in the rightmost frame.

Vii Conclusion

In this paper, we address the automated packing problem in a warehouse setting in a well-constrained manner. A constructive pipeline is developed that can pack geometrically complex, non-convex objects with stability while satisfying robot constraints. A new Heightmap-Minimization heuristic is proposed as a positioning heuristic for efficient 3D irregular shape packing. Simulation results on exhaustive datasets demonstrate the effectiveness of the pipeline and the advantage of the new heuristic in finding stable and robot-packable plans. Robot-packable plans are shown to be far more successful in open-loop execution than the simple non-overlapping plans used in prior work.

Future work could address non-rigid objects or uncertainty in 3D scanned models. Post-placement manipulation such as pushing could also increase the density of packing plans. We may also be able to increase the execution success rate by implementing a more conservative stability check, or to perform a closed-loop execution that replans once an object is observed to shift from its planned location.

References

  • [1] S. Martello and D. Vigo, “Exact solution of the two-dimensional finite bin packing problem,” Management Science, vol. 44, no. 3, pp. 388–399, 1998.
  • [2] S. Martello, D. Pisinger, and D. Vigo, “The three-dimensional bin packing problem,” Operations Research, vol. 48, no. 2, pp. 256–267, 2000.
  • [3] E. den Boef, J. Korst, S. Martello, D. Pisinger, and D. Vigo, “Erratum to “the three-dimensional bin packing problem”: Robot-packable and orthogonal variants of packing problems,” Operations Research, vol. 53, no. 4, pp. 735–736, 2005.
  • [4] T. G. Crainic, G. Perboli, and R. Tadei, “Extreme point-based heuristics for three-dimensional bin packing,” INFORMS Journal on Computing, vol. 20, no. 3, pp. 368–384, 2008.
  • [5] M. R. Garey and D. S. Johnson, “Computers and intractability: A guide to the theory of np-completeness,” 1979.
  • [6] B. Baker, E. Coffman, Jr., and R. Rivest, “Orthogonal packings in two dimensions,” SIAM Journal on Computing, vol. 9, no. 4, pp. 846–855, 1980.
  • [7] D. Johnson, A. Demers, J. Ullman, M. Garey, and R. Graham, “Worst-case performance bounds for simple one-dimensional packing algorithms,” SIAM Journal on Computing, vol. 3, no. 4, pp. 299–325, 1974.
  • [8] T. Kämpke, “Simulated annealing: Use of a new tool in bin packing,” Annals of Operations Research, vol. 16, no. 1, pp. 327–332, Dec 1988.
  • [9] D. Zhang and W. Huang, “A simulated annealing algorithm for the circles packing problem,” in Computational Science - ICCS 2004, M. Bubak, G. D. van Albada, P. M. A. Sloot, and J. Dongarra, Eds.   Berlin, Heidelberg: Springer Berlin Heidelberg, 2004, pp. 206–214.
  • [10] X. Liu, J.-m. Liu, A.-x. Cao, and Z.-l. Yao, “Hape3d—a new constructive algorithm for the 3d irregular packing problem,” Frontiers of Information Technology & Electronic Engineering, vol. 16, no. 5, pp. 380–390, May 2015.
  • [11] O. Faroe, D. Pisinger, and M. Zachariasen, “Guided local search for the three-dimensional bin-packing problem,” INFORMS Journal on Computing, vol. 15, no. 3, pp. 267–283, 2003.
  • [12]

    J. Egeblad, “Placement of two‐ and three‐dimensional irregular shapes for inertia moment and balance,” vol. 16, pp. 789 – 807, 06 2009.

  • [13] C. Voudouris and E. P. K. Tsang, Guided Local Search.   Boston, MA: Springer US, 2003, pp. 185–218.
  • [14] J. L. Viegas, S. M. Vieira, E. M. P. Henriques, and J. M. C. Sousa, “A tabu search algorithm for the 3d bin packing problem in the steel industry,” in CONTROLO’2014 – Proceedings of the 11th Portuguese Conference on Automatic Control, A. P. Moreira, A. Matos, and G. Veiga, Eds.   Cham: Springer International Publishing, 2015, pp. 355–364.
  • [15]

    J. A. Bennell, L. S. Lee, and C. N. Potts, “A genetic algorithm for two-dimensional bin packing with due dates,”

    International Journal of Production Economics, vol. 145, no. 2, pp. 547 – 560, 2013.
  • [16] L. Wang, S. Guo, S. Chen, W. Zhu, and A. Lim, “Two natural heuristics for 3d packing with practical loading constraints,” in

    PRICAI 2010: Trends in Artificial Intelligence

    , B.-T. Zhang and M. A. Orgun, Eds.   Berlin, Heidelberg: Springer Berlin Heidelberg, 2010, pp. 256–267.
  • [17] S. Diamond and S. Boyd, “CVXPY: A Python-embedded modeling language for convex optimization,”

    Journal of Machine Learning Research

    , vol. 17, no. 83, pp. 1–5, 2016.
  • [18]

    K. Y. Goldberg, B. Mirtich, Y. Zhuang, J. Craig, B. Carlisle, and J. F. Canny, “Part pose statistics: estimators and experiments,”

    IEEE Trans. Robotics and Automation, vol. 15, pp. 849–857, 1999.
  • [19] A. Lodi, S. Martello, and D. Vigo, “Tspack: A unified tabu search code for multi-dimensional bin packing problems,” Annals of Operations Research, vol. 131, no. 1, pp. 203–213, Oct 2004. [Online]. Available: https://doi.org/10.1023/B:ANOR.0000039519.03572.08
  • [20] ——, “Heuristic algorithms for the three-dimensional bin packing problem,” European Journal of Operational Research, vol. 141, no. 2, pp. 410 – 420, 2002. [Online]. Available: http://www.sciencedirect.com/science/article/pii/S0377221702001340
  • [21] Ycb benchmarks – object and model set. [Online]. Available: http://ycbbenchmarks.org
  • [22] Rutgers apc rgb-d dataset. [Online]. Available: http://pracsyslab.org/rutgers˙apc˙rgbd˙dataset
  • [23] Amazon robotics challenge official rules. [Online]. Available: https://www.amazonrobotics.com/site/binaries/content/assets/amazonrobotics/arc/2017-amazon-robotics-challenge-rules-v3.pdf
  • [24] J. Egeblad, B. K. Nielsen, and A. Odgaard, “Fast neighborhood search for two- and three-dimensional nesting problems,” European Journal of Operational Research, vol. 183, no. 3, pp. 1249 – 1266, 2007.
  • [25] Klampt - intelligent motion laboratory at duke university. [Online]. Available: http://motion.pratt.duke.edu/klampt