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 repack. 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 precomputed packing plan, several realworld 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).
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:

Noninterference. Each object is collision free,

Containment. All objects are placed within the internal space of the container,
we introduce the following constraints necessary for a robotpackable plan:

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

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 nonoverlap constraints, and constraints 14 as all constraints, or the robotpackable constraints.
While the application of robotpackable 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 robotpackable constraints.
To solve for the problem, we present the following main contributions:

A polynomial time constructive algorithm to implement a resolutioncomplete search amongst feasible object placements, under robotpackable constraints.

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

A fast prioritized search scheme that first searches for robotpackable placement in a threedimensional space that likely contains a solution, and falls back to search in a fivedimensional space.
Our algorithm and others in comparison are tested in a realistic physics simulator, by packing large quantities of random item sets using highquality, realworld object scannings. With item sizes of 35 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 HeightmapMinimization heuristic finds more placements than existing heuristics, both under nonoverlapping constraints and robotpackable 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 nonoverlapping constraints. Under some settings, such problems can be formulated and solved to optimally using the exact algorithms. One example of these stateoftheart 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 NPhard [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 “BottomLeft (BL)” heuristic [6] and the BestFitDecreasing 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 nonrectilinear 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 DeepestBottomLeftFill (DBLF), which places items in the deepest, bottommost, leftmost 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 twostage 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 MinimumTotalPotentialEnergy 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 robotfeasibility constraints simultaneously. Moreover, these constraints can be solved for arbitrary shaped 3D objects that are complex and nonconvex.
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 nonoverlapping 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.
Iiia 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.IiiB 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 topdown 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 topdown 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 pseudocode for this procedure is given in Alg. 1.
Iv Pipeline for Robotpackable Planning
We develop a constructive packing pipeline to solve for the set of robotpackable 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:

Placement sequence

Positioning heuristic

Stability check

Manipulation feasibility check
The pipeline implements a polynomial time resolutioncomplete search amongst feasible object placements under robotpackable 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 nonoverlap 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.
Iva Placement sequence
Our algorithm allows userspecified packing sequences. If a sequence is not provided, we use a nonincreasing 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 nonincreasing bounding box volume heuristic is equivalent to the nonincreasing volume heuristic when applied on rectilinear objects. The latter is known to lead to the fastest convergence of the branchandbound algorithms [2] and the good performance of the BestFit decreasing heuristics with rectangularshaped 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.
IvB 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 threedimensional search space for a geometry is defined as follows: The rolls and pitches of are restricted to be a set of planarstable 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 robotpackable solution exists in this threedimensional 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 collisionfree Z to an efficient 2D matrix manipulation. Three heightmaps are computed: 1) a topdown heightmap of the container and objects already placed (Fig. 2), 2) a topdown heightmap of the object to be placed, measured relative to the lowest point at the object’s given orientation, and 3) a bottomup 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 axisaligned 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 collisionfree Z as follows:
(9) 
where are the pixel coordinates of , and to be the dimensions of .
Once all legal candidate transforms are obtained, they are scored by a scoring function formulated from a positioning heuristic. For example, the DeepestBottomLeftFirst 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 nonoverlap 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.
IvC 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 robotpackability.
The overall pipeline for packing multiple objects is given in Alg 4. Given a heuristic packing sequence (nonincreasing boundingbox volume), it calls Alg. 3 for each item with the set of planarstable 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.)
V HeightmapMinimization Heuristic
The performance and solution quality of a multidimensional packing problem is highly susceptible to the itempositioning 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, multilayer positioning rules for irregular shapes, particularly nonconvex shapes, have not been sufficiently addressed in the previous literature. To address these shortcomings, we propose a novel positioning heuristic called the HeightmapMinimization (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. IVB. 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.
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.
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 realworld 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 planarstable rolls and pitches with the highest quasistatic probabilities are used. Up to 100 legal placement candidates are checked for stability and manipulation feasibility.
Via 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, 35 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 35 models randomly selected from the APC and YCB datasets. The tested algorithm uses the HM heuristic and is required to obey all robotpackable 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).
ViB 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 nonoverlapping placement for the set within the container using all of our tested methods. (Robotpackability 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 nonoverlap 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 robotpackable 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.
The success rate for GLS under robotpackable constraints is not reported as such constraints were not implemented in the previous GLS works. Generally speaking, implementation of robotpackable 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, nonoverlap (%)  99.9  98.4  88.9  78.9 
Time, nonoverlap (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  — 

Empirically, HeightmapMinimization finds more solutions than any other method in comparison, under all degrees of constraint. With a nonoverlapping 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 robotpackable 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.
ViC Executing Complex Packing Plans
Finally, we test openloop 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 topdown 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 topdown 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 (35 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 robotpackable plans obtained with HM heuristic were executed successfully according to our success criteria. Using the nonoverlap 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)  
Nonoverlap constraint  17.11  1.95  1.29 
All constraint  79.1  1.36  0.50 

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.
Vii Conclusion
In this paper, we address the automated packing problem in a warehouse setting in a wellconstrained manner. A constructive pipeline is developed that can pack geometrically complex, nonconvex objects with stability while satisfying robot constraints. A new HeightmapMinimization 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 robotpackable plans. Robotpackable plans are shown to be far more successful in openloop execution than the simple nonoverlapping plans used in prior work.
Future work could address nonrigid objects or uncertainty in 3D scanned models. Postplacement 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 closedloop 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 twodimensional finite bin packing problem,” Management Science, vol. 44, no. 3, pp. 388–399, 1998.
 [2] S. Martello, D. Pisinger, and D. Vigo, “The threedimensional 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 threedimensional bin packing problem”: Robotpackable 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 pointbased heuristics for threedimensional 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 npcompleteness,” 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, “Worstcase performance bounds for simple onedimensional 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 threedimensional binpacking 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 twodimensional 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 Pythonembedded 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 multidimensional 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 threedimensional 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 rgbd 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/2017amazonroboticschallengerulesv3.pdf
 [24] J. Egeblad, B. K. Nielsen, and A. Odgaard, “Fast neighborhood search for two and threedimensional 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
Comments
There are no comments yet.