GB2524952A - A method of packing containers - Google Patents

Abstract

A packaging method including the steps of creating a list of sets of items, each item in the set to be shipped together; the list including the dimensions and mass of each item and specifying whether each item can support another item. Sets form the list are virtually selected so the sum of the sets masses are close to a particular threshold without exceeding it. The items of the selected sets are virtually arranged in stacks which are one or more items tall so that: no stack height exceeds a particular threshold; only items which can support items have items stacked on them; an item is at least as large in two dimensions as the item above it; and the number of stacks is minimised. Whether the bottom items can fit in a predefined region is then determined and if they can a list of the items is created. Ideally a real life container 16 is packed with real life items 15 by robots 19 according to the list.

Description

A method of packing containers This invention relates to a method of packing containers and in particular to a method of optimising the packing of items in a container. The method is particularly suitable for packing heavy items and groups of items in which only some of the items can support other items in a stack, and only some of which can adopt different orientations within the container. The method is especially advantageous in packing shipping containers with groups of palletized goods, such as boxes of bearings.

The Container Loading Problem describes the three-dimensional problem of packing a given set of three-dimensional rectangular boxes into a three-dimensional rectangular container such that a given objective function is maximized, and if applicable, some other constraints are satisfied. Generally, the objective function to be maximized is often the volume utilization of the container. Some common constraints include: a volume constraint for the loaded boxes; a weight constraint for the entire packed load; an orientation or box rotatability constraint; and a stacking constraint (i.e. boxes may or may not allow for other boxes to be placed on them). A selected packing is said to be viable if all the selected boxes are packed completely within the walls of the container and there is no overlap between any of the boxes.

The container loading problem is an active research area and has numerous applications in the real world, particularly in container transportation and distribution industries. It is well known that it is an NP-hard problem (Non-deterministic Polynomial-time hard). A variety of mathematical formulations for Container Loading Problems can be found in literature; however, the direct application of exact algorithms for the implementation of these mathematical models has proven to be computationally feasible only for problem instances of very limited size (see Nepomuceno N, Pinheiro P, Coelho ALV. Tackling the Container Loading problem: A hybrid approach based on Integer Linear Programming and Genetic Algorithms. In: Cotta C, VanHemertJ, editors.

evolutionary computation in combinatorial optimization, proceedings. heidelberger platz 3, d-14197 berlin, germany: springer-verlag berlin; 2007. p. 154-65 and Hwang 5, Kao C, Horng J. On Solving Rectangle Bin Packing Problems Using Genetic Algorithms. In: 1994 IEEE International Conference On Systems, Man, And Cybernetics -Humans, Information And Technology, Vols 1-3. 345 E 47th St, New York, NY 10017:1 E F F; 1994. P. 1583-90). This has led to majority of studies focusing on providing solutions from heuristics and meta-heuristic approaches.

Several approaches have been proposed in literature for solving the Container Loading Problem. Many different constraints and objectives have also been considered, with recent emphasis placed on practical constraints that are often of importance in real world scenarios. The most common approach is a layering approach. This is based on the concept of packing items from the ground up in layers. There is also a wall-building approach where the container is filled with walls. The walls are rectangle blocks made up of boxes, and their depth is determined by the first box placed in them.

Approaches have been hybridized to solve specific variants of the container loading problem. More recently, parallel versions of some meta-heuristic approaches have been investigated.

The primary function to be maximized in literature is normally the volume utilization of the container. Only a few approaches found consider maximizing weight as their objective function, and even then, they do so in combination with the maximization of some other value. Dereli T, Das Gs. A Hybrid Simulated Annealing Algorithm For Solving Multi-Objective Container-Loading Problems. Applied Artificial Intelligence.

2010;24(5):463-86 aims to maximize weight and volume utilization. He D, Cha J. Research on solution to complex container loading problem based on genetic algorithm.

In: 2002 International Conference On Machine Learning And Cybernetics, Vols 1-4, Proceedings. 345 F 47th St, New York, Ny 10017 USA: IEEE; 2002. p. 78-82 seeks to maximize the volume utilization and weight utilization of the container and to minimize the height of the centre of gravity. Dereli T et al highlights the conflict that exists when trying to maximize both weight and volume. In practice, one of weight or volume will be satisfied at the expense of the other.

In a real world scenario, containers often have a weight limit on the total cargo they can carry. If it is more important that a higher number of boxes is packed, the volume should be maximized before weight. If however, like in the problem identified and addressed by this invention, there is no value attached to the boxes, and the primary objective is to pack as much as the container can carry, the weight is maximized before the volume.

Various proprietary software is available which is intended to solve the problem of how to pack a container, such as a shipping container. However, none is available that takes account of all the constraints relevant to minimising the number of shipping containers required to ship large numbers of jobs which each comprise one or more pallets of heavy goods, such as bearings, in which the palletized goods may be of different size and weight, and in which some pallets may be stackable" in the sense that they can support goods on top of them, whereas others may not and some pallets may be able to take more than one different orientation, whereas in order to be carried by (for example) fork-lift trucks, other pallets may only be able to take one orientation within a container.

As a result of these shortcomings, containers are still often packed by an entirely manual process, in which skilled trained loaders attempt to fill containers according to selections made by sales operatives, who make selections based solely on the weight of the jobs. Even dealing with a weakly heterogeneous system with just a few "box-types" (i.e. different size/weight palletized goods) and many boxes it is not unusual for the job selection process to take about 10 minutes and for loaders to take up to an hour to determine whether or not the selected jobs can actually be loaded. Moreover, even following this process, the jobs considered to be loadable may prove not to actually fit in the container and conflict and confusion between loaders may remain.

The present invention seeks to provide an improved method of packing containers, such as shipping containers.

Against this background there is provided a method according to claim 1.

This method splits the problem into three sub-problems focussing first on ensuring that the weight is maximised, then identifying the smallest amount of floor space that the selection of greatest weight requires, by creating sets of stacks, then finally checking whether the stacks can be packed into the container before outputting a list of the items to be packed. This method ensures that containers are packed as close to their weight capacity as possible, which reduces the cost of shipping as fewer containers are required and has knock-on effects in teims of reduced emissions as fewer vehicles are required to carry the containers.

Preferably, if the stacks cannot be packed into the container, the stacking algorithm and the packing algorithm are run on the next-fittest job selection, until a job selection is obtained that can be packed completely on the container floor, and then a list of the items for that successful packing arrangement is outputted.

Preferably the container is a shipping container. Alternatively the container may be a trailer or the cargo bay of a fixed-body lorry.

Preferably the items are palletized goods. More preferably the palletized goods are palletized boxes of goods, especially heavy goods such as boxes of bearings or the like. The method is most useful for such cases, as maximising the weight is prioritised over utilisation of available volume.

Preferably the stacking algorithm ensures that the weight of each top item is less than the weight of each bottom item. This can improve stability of the stacks.

Preferably the list of items to be packed into the container is displayed graphically.

More preferably the list of items is displayed graphically as a 3D representation of the items in the container. This can assist in the final step of packing the items into the container.

Preferably the selection algorithm is the presented as a one-dimensional knapsack problem in which the container represents the knapsack, the jobs represent the items to be selected and the value of an item is the total weight of the items in the job. More preferably the selection algorithm is a genetic algorithm Preferably the stacking algorithm is a greedy algorithm.

Preferably the stacks consist of either a bottom item alone or a stack of only two items consisting of a top item supported directly on top of the bottom item. Alternatively the stacks of at least two items may comprise more than two items, such as three or more items, in which case preferably each item is lighter than and has smaller length and breadth than the item it is on top of.

Preferably the packing algorithm is an order based genetic algorithm integrated with a rectangle packing algorithm.

Suitably the rectangle packing algorithm is the CygonRectanglePacker.

Preferably the method is implemented using a computer.

Preferably the method further comprises the step of packing a container with the items identified in the output. Such packing could be manual or automated, for example by use of robots.

Preferably the method further comprises the steps of inputting data representing whether each item has a fixed orientation in the container; and the packing algorithm takes into account whether each bottom item has a fixed orientation when determining whether the stacks can be packed into the container. This step is especially useful when handling mixtures of palletized goods, some of which may be picked up along their length and along their breadth by a fork lift truck or the like, and some of which may only be carried by a fork lift truck or the like along their length or their breadth.

Preferably in the method, at least one job consists of a plurality of items which must be shipped together and in the step of running the selection algorithm, jobs are only selected to populate the container when all the items in said job are included in the job selection. This step is extremely useful in attending to the situation described above, in which several items (e.g. several pallets of goods) must be delivered in a group, i.e. as a single job.

In a second aspect, there is provided a computer programmed to carry out the method. In a third aspect, there is provided a computer program which carries out the method. In a fourth aspect, there is provided a computer readable medium programmed to carry out the method.

Further aspects and features of the invention will be apparent from the following non-limiting detailed description of certain embodiments of the invention, which refers to the figures, in which: Figure 1 is a flow diagram of the container loading algorithm according to the first embodiment of the invention; Figure 2 is a flow diagram of the genetic algorithm used as the job selection algorithm in the container loading algorithm of figure 1; Figure 3 is a graphical representation of the one-point crossover operation used in the mating process of the job selection algorithm of figure 2; Figure 4 is a graphical representation of the mutation operation used in the reproduction process of the job selection algorithm of figure 2; Figure 5 is a flow diagram of the greedy algorithm used as the stacking algorithm in the container loading algorithm of figure 1; FigureS is a flow diagram of the packing genetic algorithm used in the packing algorithm in the container loading algorithm of figure 1; Figure 7 is a schematic representation of palletized goods packed in a shipping container in accordance with the method of the invention; Figure 8 is a flow diagram of the fitness evaluation algorithm used in the packing genetic algorithm of figure 6; Figure 9 is a graph showing the weight utilisation of a container filled by the method of the embodiments of the invention and a comparative manual process; Figure is a graph showing the computation time for determining the method of packing a container with items according to the methods of the embodiments of the invention; Figure 11 is a schematic representation of a system for carrying out the method of packing a container in accordance with the algorithm of figure 1; and Figure 12 shows the robots of figure 11 carrying out the method.

The embodiments of the invention are methods for loading a weakly heterogeneous set of items, in this case palletized goods (or "pallets") into a container, in this case a shipping container.

This is a modification of the basic container loading problem which can be formulated as follows: Given a set of rectangular boxes and a container, load a subset or all of the boxes entirely into the container such that the volume of the loaded boxes is maximized, and there is no overlap between boxes.

The loading problem of this embodiment differs from the basic problem. Boxes (i.e. palletized goods) are placed into groups such that if a box is selected for loading, all other boxes in its group must be loaded as well -such a group is refeired to as a "ob".

The objective to be maximized is the total weight of the loaded boxes, not the volume.

These variations, as well as other practical constraints specific to the problem are reflected in the model. The model for the problem is thus defined as: Given a set of g jobs, each made up of n pa/lets with length (I), breadth (4), height (h), weight (wj), and a single container with dimensions (L, B, H) where i«= L, b7«=B,and h!«= H, and the maximum weight capacity of the container/s W,nax.

Consider the container embedded into a 3D Cartesian reference frame in such a way that the lower-left-near corner coincides with the origin and the upper-right-far corner coincides with point (L, B, H). Select a combination of jobs for packing into the container where all pa/lets for the selected jobs are packed without any overlapping while maximizing the total weight of the packed pellets.

The following assumptions are made: * Pallets are rectangular boxes with known dimensions (li, , h1).

* A job is a group of pallets that are not allowed to be separated and must be kept together. If a pallet is selected for loading from a group, all other pallets belonging to the same group must be loaded as well.

* The square area of the top or bottom of a pallet (l * b) is represented as sq * Each pallet is placed in the container orthogonally, i.e. the pallet edges are either parallel or perpendicular to the container edges.

* Some pallet types can be rotated and placed in a maximum of 2 possible orientations while others can only be placed in 1 orientation. r1 is a binary variable that equals 1 if a pallet is rotatable, or 0 otherwise.

* s is a binary variable that equals 1 if pallet] from job i is placed in the container, or 0 otherwise.

* is a binary variable that equals 1 if palleti can be placed on pallet], or 0 otherwise.

* If pallet] is packed into the container, let (x11, yp, z11) and (x12, y12, z12) denote the coordinates of its lower-left-near corner and upper-right-far corner, respectively.

* A pallet can be stackable or not. Being stackable means another pallet can be placed on top of it. st1 is a binary variable that equals 1 if pallet] is stackable, or 0 otherwise.

* Each pallet can lie on the container floor or be stacked on top of another stackable pallet.

* A pallet cannot be placed on top of another pallet if it is heavier than the pallet it is to be placed on.

* Pallets cannot be stacked higher than a given maximum height (H,nax).

* If a pallet! is placed on a pallet], no other pallets can be placed on pallet / (i.e. there can only be a maximum of two pallets in a stack).

The problem is therefore formulated as: Maxim ize (1) subject k: (2) (3) rne4 fl4(X, X. F-P In( X) mx(y?. y,)-mM(v?}y, 4 rnax(z,z1.) -mtn(z,, z;ss»=o, (i!=j), r (xxy;yq.,zz)((i.,b,kJJb0!1,h.'].

1. . (5) (mar(y, -min(y, i)) Lçs«= (6) (Hf w.«=w,,sq..«=sqst=1. (7) to

i=1,..,g. (8) s.(O,t. i=t,...,g (9) The objective function (1) maximizes the total weight of the jobs packed.

Constraint (2) ensures that the total weight of all the pallets for all the selected jobs does not exceed the weight capacity of the container; constraint (3) implies that each packed pallet is packed completely within the walls of the container; constraint (4) implies that there is no overlapping between any two packed pallets; constraint (5) denotes whether a pallet is rotatable or not. If pallet] is rotatable, pallet] has 2 possible orientations whose dimensions on the x-, y-and z-axes are (,, b1, h1), and (b1, 1), h1), otherwise pallet] has only 1 possible orientation whose dimension on the x-, y-and z-axes is (Ii, b1, h1); -10 -constraint (6) implies that the height of a stack of pallets cannot exceed the maximum allowed height for the container; constraint (7) states that pallet / can be placed on pallet ] if the weight of pallet i is less than or equal to the weight of pallet], the bottom surface area of pallet I is less than or equal to the top surface area of pallet], and pallet] is stackable; constraint (8) implies that if a job! is selected, all the pallets that belong to job fare selected; and constraint (9) denotes whether a pallet is packed into the container or not.

The method is carried out by a "Load Optimisation Algorithm" which is an iterative procedure combining three heuristic algorithms: a selection algorithm; a stacking algorithm; and a packing algorithm. The selection algorithm solves a one-dimensional knapsack problem. It selects a combination of jobs (groups of pallets) for loading onto a container, maximizing the weight capacity of the container. The stacking algorithm stacks a given list of pallets. It sorts pallets in descending order of weight, and iteratively attempts to stack if possible, lighter/smaller pallets on top of heavier/bigger ones while keeping the stack height below the maximum allowed height for the container. The packing algorithm solves a two-dimensional rectangle packing problem. It packs a given list of stacks onto the container floor. Its result is whether the stacks can be packed entirely onto the container floor or not.

The Load Optimization algorithm shown in Figure 1 starts by preparing required input data and running the selection algorithm. The resulting list of job selections is iterated through, and for each selection, a list of pallets is generated from the selected jobs. This list of pallets is provided as input to the stacking algorithm which produces a list of stacks as output. The packing algorithm takes the list of stacks as input and determines if the stacks can be packed or not. The iterations continue until the packing algorithm finds a list of stacks that can be packed, or until all the job selections have been evaluated.

The Selection Algorithm -11 -The selection algorithm of this embodiment is a one-dimensional knapsack problem, in which there are n items. Each item x has a value and a weight w,. The knapsack has a maximum weight capacity W. All values and weights are assumed to be non-negative. The problem is then to select items from the set of items such that the total weight is less than or equal to the weight capacity of the knapsack. The problem can be modelled mathematically as follows: Maximize: ii V1X, 10) subject to: w1x«=W. xE{O, 11 11) In the selection problem, the container is the knapsack, and jobs are the items to be selected. The value of a job is its weight. The problem then is to obtain a selection of jobs with total weight less than or equal to the weight capacity of the container.

The genetic algorithm shown in figure 2 is used to solve this problem as it is a meta-heuristic approach adopted for solving difficult combinatorial optimization problems, and given the size of the problem, can be guaranteed to provide good results.

Also, the genetic algorithm code can be used and further extended for the packing algorithm; this helps reduce programming effort.

In the genetic algorithm shown in figure 2, a candidate solution is represented as a chromosome which is encoded as an array of bits with length equal to the total number of jobs available. Each bit represents a different job, and the value of the bit (0 or 1) represents whether or not the job was selected for inclusion in the container. The quality of a solution is known as its fitness. The fitness of a chromosome is the sum of weights of all jobs selected for inclusion in the container if the sum does not exceed the -12 -container's weight capacity, otherwise a penalty function is applied and the fitness is zero.

An initial population of candidate solutions is randomly generated, the fitness of each chromosome is calculated, and the population is sorted according to fitness. This population is known as the first generation.

For the second generation, the population is created by first copying over the chromosome with highest fitness from the previous population (this concept is called elitism). Two chromosomes are selected from the previous population using tournament selection. Based on a crossover probability, these two parent chromosomes are either mated or cloned to produce two children chromosomes. The mating process is a one-point crossover operation which involves selecting a random point in both chromosomes, and swapping their end parts as shown in figure 3. The cloning process is simply creating an exact copy of a chromosome. Based on a mutation probability, the resulting children are mutated. In the mutation operation, as shown in figure 4 a random position in the chromosome is selected, and its bit is reversed (i.e. if the bit isO, it is changed to 1, and if it is 1, it is changed to 0). The reproduction process is repeated until the number of chromosomes in the current generation equals the population size. Subsequent generations are created using the same procedure until a given limit for generation size is reached.

The solution of the selection algorithm is the population of chromosomes in the final generation. The population represents the list of job selections. Each job selection in the solution satisfies the first two practical constraints: * The total weight of all the packed boxes must not exceed the weight capacity of the container.

* All the items in any one job must be packed in the same container.

The job selections are sorted by fitness to ensure that when the Load Optimization algorithm is iterating through the list, it will stack and pack selections with a higher fitness -13 -before those with a lower fitness. This way when a solution is found to fit wholly onto the container, no other solutions exist in the population with a better fitness.

The Stacking Algorithm In this embodiment, the stacking algorithm stacks a list of pallets subject to the following third and fourth practical constraints: * Boxes can have other boxes placed on them or not. If a box can be stacked on, the weight of the box to be placed on it must not be greater than its weight; also, the area of the bottom surface of the box to be placed on it must not be greater than the area of its top surface.

* When boxes are stacked on each other, there can only be a maximum of two boxes in a stack, and the height of a stack must not exceed a given maximum height for the container.

A greedy algorithm shown in Figure 5 is used for stacking the pallets. Based on the constraints identified above, pallets are categorized into two: stackable and non-stackable. The algorithm begins by separating input pallets into two lists according to the above categorization; a list of stackable pallets (which are items which can support another item), and a list of non-stackable pallets (which are items which cannot support another item). The pallets in each list are then sorted in descending order by weight. A stack data structure is defined that can hold two pallets; one as the bottom pallet, and another as the top pallet. Use of this data structure ensures that a stack cannot contain more than two pallets. Of course in other embodiments of the invention, stacks of more than two pallets may be desirable.

The algorithm proceeds to iteratively generate stacks by attempting to use stackable pallets before non-stackable pallets as bottom pallets and non-stackable pallets before stackable pallets as top pallets.

While searching for a bottom pallet, stackable pallets are considered first so that there is room for another pallet to be placed as a top pallet. Since the list of stackable -14 -pallets is sorted by weight in descending order, heavier pallets are guaranteed to be selected before lighter ones. This way, if another pallet in the same list is selected as a top pallet, it is not heavier than the bottom pallet. If a pallet is selected from the list of non-stackable pallets as a bottom pallet, no other pallet can be placed on it.

While searching for a top pallet, non-stackable pallets are considered first to ensure that a stackable pallet that can be used as a bottom pallet is not wasted as a top pallet. If a pallet is found that satisfies all the required constraints (weight, surface area, maximum stack height), it is selected as a top pallet; otherwise, other pallets in the list are considered until a suitable pallet is found. If none is found, the algorithm proceeds to check the list of stackable pallets for a suitable pallet.

If a bottom and top pallet can be selected for a stack, the stack is complete and added to a stack list. If only a bottom pallet can be selected for a stack, with no suitable top pallet found, the stack is considered complete and added to the stack list. Stacks are generated and added to the stack list until there are no more pallets to be considered for stacking.

The solution to the stacking algorithm is the resulting list of stacks. The greedy approach used for the stacking algorithm guarantees that the total number of stacks generated is minimized. This is important because a lower number of stacks increases the chances of the entire stack list being packed completely onto the container floor.

The Packing Algorithm The packing algorithm of the present embodiment solves the two-dimensional rectangle packing problem, which is the problem of packing a given set of small rectangular pieces into a larger containing rectangle. It is assumed that the rectangles are placed orthogonally. There are many variants of the two-dimensional rectangle packing problem, many of which may have a fixed orientation, or can be rotated by 90°, and additionally may or may not impose that the pieces are obtained through a sequence of edge-to-edge cuts parallel to the edges of the larger rectangle. The variant -15 -according to the present embodiment of the invention is that of packing a given set of rectangles completely into a single larger rectangle.

In the packing problem, there are a given set of stacks which represent the small rectangles to be packed, and the container floor which represents the larger rectangle.

Some of the stacks, depending on the type of pallets that make up their base, can be rotated by 900 to give two possible orientations, while the rest can have only one orientation. The problem then is to determine if the given set of stacks will fit entirely onto the container floor.

In this embodiment, an order-based genetic algorithm integrated with a rectangle packing algorithm is used for solving the problem, as shown in figure 6. Order is important because the results obtained from the rectangle packing algorithm employed vary based on the order (and orientation) of the rectangles it is given to pack, as illustrated by figure 7. Figure 7 shows packings obtained by the Rectangle Packing Algorithm for 8 rectangles based on order and orientation of rectangles. The order for packing 1, of figure 7.1 is: A BC D E F G H; for packing 2, of figure 7.2, the order is G A* 8* C D F F H and for packing 3 of figure 7.3 the order is A* 8* C D F F* G H. An asterisk (*) next to a rectangle means the rectangle is placed in its second orientation. Only the packing of figure 7.3 is able to pack all the stacks into the container.

The algorithm is designed in such a way that any rectangle packing algorithm can be modified and easily integrated with it. The rectangle packing algorithm used in the proposed solution is one of a group of packing algorithms provided primarily for games development.

The operation of the packing genetic algorithm shown in figure 6 is quite similar to that of the selection genetic algorithm, with a few differences. In the packing genetic algorithm, a chromosome is represented as an order-based list of stacks, with each stack having an orientation property (0 or 1) that determines what orientation the stack is packed in. The initial population is generated by randomly assigning the orientation of -16 -each stack in a given stack list to 0 or 1, and shuffling the order of the stacks in the list.

The fitness of a chromosome is evaluated by means of the rectangle packing algorithm and set to the number of stacks the algorithm is able to successfully pack onto the container floor from the stack list. During evaluation, the pallet bottoms of the stacks are checked to see if they can be rotated; if they can, they are packed in the orientation assigned to the stack; if not, they are packed in one orientation irrespective of the orientation assigned to the stack. This satisfies the fifth constraint: * Boxes can be rotated or not. If a box is allowed to rotate, it can only be placed in any of two given orientations; otherwise, it can only be placed in one way While generating subsequent populations, a random selection method is used for selecting chromosomes for reproduction. This is because if a given stack list is known to fit, each chromosome in the population has a high chance of being completely packed based on the order and orientation of its stacks. A one-point crossover operation, which selects a random point in both chromosomes selected and swaps the orientations of the stacks in the end pads, is used for mating the selected parent chromosomes. The mutation operation used shuffles the order of a chromosome. In addition, if during the operation of the packing genetic algorithm, a chromosome is evaluated and found to have fitness that equals the number of stacks to be packed (i.e. the stacks can be packed completely), the algorithm terminates as a solution has been found. If the algorithm runs till it reaches the maximum number of generations, no solution was found.

The fitness evaluation process described above can be seen in more detail in figure 8.

The Rectancile Packinci Algorithm The rectangle packing algorithm employed in the present embodiment of the invention is called the CygonRectanglePacker. It is named after its author, Markus Cygon' Ewald, and was selected because it is quite efficient in its space usage and offers good peiformance. It never exceeds 0(n) time but generally achieves almost 0(1) -17 - on average thus providing a very good compromise between space-efficiency and time-efficiency.

The algorithm always places rectangles as low as possible in the packing area (i.e as close as possible to the back of the container). So, for any new rectangle that is to be added, it has to determine the X coordinate at which the rectangle can have the lowest overall height without intersecting any other rectangles. To quickly discover these locations, the algorithm uses a sophisticated data structure that stores the upper silhouette of the packing area. When a new rectangle needs to be added, only the silhouette edges need to be analysed to find the position where the rectangle would achieve the lowest placement possible in the packing area.

Examples

The Load Optimization algorithm discussed above has been implemented using a PC running ArchLinux with an lntel(R) Core(TM) i3 M 330 © 2.13GHz CPU and 4GB RAM. Programming has been done in the C# programming language. Development of the user interface and testing has been performed using GTK# in MonoDevelop.

The program takes as input container information, pallet types, and pallet information for all available pallets. The container dimensions and maximum weight allowed are entered directly by a user into the user interface. An iteration parameter can also be specified as input; this controls the number of times the algorithm is run, and results in the selection of the best solution found for all iterations.

The pallet type information is supplied as a text file called "pallet-types.ini". This file is expected for the program to run and should be located in the root folder of the program. The file contains information about all the different pallet types the algorithm should make use of, their dimensions, and if their orientation can be changed or not. In the examples the format for the data separated by tabs or spaces, and entered line by line is of the following format: <pa/let type name> </ength> <breadth> <rotatable> -18 -The length and breadth are entered as integer values; rotatable has a value of 1 if the orientation of the pallet type can be changed, or 0 if otherwise. An example is shown

in table 1 below.

Table 1. Examples of Pallet Type input data Pallet type Length (cm) Breadth (cm) Can orientation change SMALL 70 70 1 MEDIUM 80 100 1 LARGE 120 150 0 In the examples pallet information is also supplied as a text file. The file can be of any name, and will be selected when the program is run. The file contains pallet information showing the pallet name, weight, length, breadth, height, and a value showing whether the pallet is stackable or not, in the following format separated by tabs or spaces: <pallet name> <weight> <length> <breadth> <height> <stackable> The pallet name in the examples consists of a job name and pallet number separated by a "1' (e.g. JOBOO1/001, JOBOO1/002, 1TEM440120, ITEM44O/45 are all valid pallet names). The weight can be entered as a decimal value (e.g. 250.40) or an integer value (e.g. 300); and the length, breadth and height as integer values; and "stackable" is entered with a value of 1 if the pallet is stackable or 0 otherwise.

Exemplary data is shown in table 2 below:

Table 2

Pallet name Weight Length Breadth Height Stackable (kg) (cm) (cm) (cm) JOBO1/Ol 450 34 26 54 0 JOBO1/02 345.2 34 65 45 0 JOBO2/04 500 120 150 78 1 -19 -In the examples, genetic algorithm parameters for the selection and packing genetic algorithms are available in a file called "ga-settings.ini" available in the root directory of the program.

The output of the Load Optimization program of the examples is either a selection of jobs for loading after satisfying all constraints, or a message saying no selection could be found that fits onto the container.

The output includes the container dimensions that were supplied and a list of the jobs selected by the algorithm. If when the algorithm is run, the option to show pallet information is selected, pallet information for all the selected jobs is shown as well. In the examples best, average and worst-case utilization and computation time achieved by the algorithm for the number of iterations specified is shown. The total time it takes for the algorithm to run all iterations is also displayed.

The performance of the Load Optimization algorithm was evaluated via computational experiments performed on real data obtained from the logistics department of the applicant. For security reasons, pallet names, which normally contain some part of a customer order number, have been changed. However, all other pallet data is exact. All experiments are performed on a PC running ArchLinux with an lntel(R) Core(TM) i3 M 330 @2.13GHz CPU and 4GB RAM. Solutions obtained from the Load Optimization algorithm were validated by experienced loaders and all solutions validated have been found to be correct. A summary of 50 validated solutions, each having a weight utilization of 100%, is set out below in table 3.

Table 3 Summary of 50 confirmed packings that have a 100% weight utilization Number of pallet types Solutions 1/ STD NSK EURO Total EURO pallets Solution #1 1 48 22 3 74 -20 -Number of pallet types Solutions 1⁄2 SID NSK EURO Total EURO pallets Solution#2 1 42 11 11 65 Solution #3 0 49 14 5 68 Solution #4 0 36 20 9 65 Solution #5 0 42 22 3 67 Solution #6 1 39 20 3 63 Solution #7 2 36 25 3 66 Solution #8 1 25 32 2 60 Solution #9 1 28 28 3 60 Solution #10 1 23 31 3 58 Solution #11 0 23 33 6 62 Solution #12 1 22 24 11 58 Solution #13 0 28 31 6 65 Solution #14 0 30 25 12 67 Solution #15 2 40 24 6 72 Solution #16 2 41 26 2 71 Solution #17 0 48 18 2 68 Solution#18 0 39 16 13 68 Solution #19 0 36 20 9 65 Solution #20 3 27 22 7 59 Solution #21 3 25 26 6 60 Solution #22 0 24 28 7 59 Solution #23 2 16 17 16 51 Solution #24 3 19 27 7 56 Solution #25 4 21 29 6 60 Solution #26 3 16 32 6 57 -21 -Number of pallet types Solutions 1⁄2 SID NSK EURO Total EURO pallets Solution #27 3 24 28 5 60 Solution #28 5 19 27 0 51 Solution #29 5 21 32 3 61 Solution #30 5 21 35 1 62 Solution #31 3 49 16 3 71 Solution #32 4 32 14 13 63 Solution #33 5 34 20 5 64 Solution #34 3 40 22 2 67 Solution #35 3 19 22 14 58 Solution #36 2 32 21 6 61 Solution #37 3 40 15 6 64 Solution #38 0 32 20 6 58 Solution #39 2 21 18 12 53 Solution #40 1 22 25 7 55 Solution #41 3 35 22 2 62 Solution #42 1 20 13 19 53 Solution #43 1 27 26 3 57 Solution #44 3 22 22 10 57 Solution #45 4 23 28 3 58 Solution #46 5 20 24 3 52 Solution #47 3 25 27 3 58 Solution #48 2 25 28 3 58 Solution #49 1 42 8 13 64 Solution #50 5 20 33 1 59 -22 -Results obtained from problem sets in their normal and extended form were compared with results from the manual process employed at NSK. Comparisons made were based on the weight utilization of the packings obtained by both approaches. As it is expected that the Load Optimization algorithm will provide results in times better than or as good as the best-case time for the manual process, no comparison is made with the manual process based on time. As it was impossible to obtain an exact measure of the time spent by the manual process on selecting pallets and determining if they will fit onto a container, we assume an approximate value of 10 minutes; this represents the best-case time assuming the first selection made fits and is immediately verified by an experienced loader -as set out above, this is unusual in practice.

Problem Sets The embodiment of the invention was applied to 15 exemplary problem sets set out in table 4, each comprising on average of 22 jobs and 331 pallets. Problem set 1 is set out in its entirety in table 12, which follows the description. The pallets are weakly heterogeneous with only 4 different types of pallets (see TableS) used across all problem sets. The pallet number, weight, length, breadth and height of each pallet is given. As no input data is present for the stackable constraint, all pallets are initially assumed to be stackable. The problem sets are further extended to consider the introduction of a stacking constraint. This is done by randomly generating and assigning stackable values to pallets during computation.

Table 4. Summary of problem sets

Problem Number Number of Total Weight Set of Jobs Pallets (kg) P5(1) 37 390 173947 PS(2) 35 299 118168 P3(3) 29 332 147675 P5(4) 25 279 121957 -23 -Problem Number Number of Total Weight Set of Jobs Pallets (kg) PS (5) 22 251 97070 PS(6) 25 298 121574 PS (7) 24 236 92502 P3(8) 18 181 71011 PS(9) 21 215 96328 P5(10) 19 173 66698 PS(11) 8 113 45081 P5(12) 17 161 71704 P3(13) 14 103 46892 P3(14) 13 116 44459 P3(15) 24 335 138405 Table 5. Pallet types and their orientations Pallet Type Length Breadth Can change Possible orientation orientations Y2EURO 80cm 60cm Yes 0,1 STD 80cm 70cm Yes 0,1 NSK 105 cm 75cm No 0 EURO 120cm 81 cm Yes 0, 1 As set out in table 6 below, the same parameters for the container, corresponding to a standard shipping container, were used in all cases.

Table 6. Container parameters used across all problem sets Container Parameters Container length (L) 1203 cm Container breadth (B) 235 cm Maximum allowed height (Hmax) 210cm -24 -Maximum weight (W) 25999 kg Genetic Algorithm Parameters The selection and packing genetic algorithms have parameters that control their performance and operation. These parameters can take on a wide range of values.

Generally, increasing the population and generation size results in better performance, but at the cost of increased computational time. Experiments were therefore performed to obtain parameters that achieve a good balance of optimal results and computation time. Table 7 below shows the results obtained for varying generation sizes of the selection genetic algorithm for 2 problem sets; one with stacking considerations and the other without:

Table 7

Problem Generation Load Optimization algorithm sets size Weight Utilization (%) Time (s) Worst Average Best Worst Average Best PS (1) 200 94.76 98.97 100 42.92 10.78 0.11 (pallets 400 97.1 98.9 100 32.78 10.86 0.23 have varying 500 95.78 99.21 100 53.91 10.64 0.28 stackable parameter 1000 93.54 99.17 100 40.59 10.18 0.56 s) 1500 93.25 98.93 100 71.84 12.77 0.85 Ps (1) 200 99.28 99.96 100 9.93 0.62 0.11 (all pallets 400 99.99 100 100 3.62 0.52 0.23 assumed tobe 500 100 100 100 2.93 0.50 0.28 stackable) 1000 100 100 100 5.16 0.82 0.56 1500 99.16 99.89 100 7.46 1.73 0.83 Values for crossover probability, mutation probability, and population size are set to 0.8, 0.05, 200 respectively for the selection genetic algorithm, and values for crossover -25 -probability, mutation probability, population size and generation size are set to 0.8, 0.05, and 300 respectively.

From the experiments performed, it was found that increasing the generation size beyond 500 has very little effect on the performance of the algorithms, but increases the computation time linearly. A population size of 100 gives optimal results on average but results in low performance for large problem sets. A population size of 200 is thus selected so that uniform performance is obtained across large and small problem sets.

Increasing the population size beyond 200 has little or no effect on performance, and only increases computation time. Crossover and mutation probabilities of 0.8 and 0.05 were decided upon.

Similar experiments were performed on the packing genetic algorithm. The parameters selected are shown in Table 8: Table 8. Suitable Genetic Algorithm parameters Selection GA. Packing GA.

Probability of 0.8 0.8 Crossover Probability of Mutation 0.05 0.2 Population Size 200 100 Number of Generations 500 300 Based on the experiments performed, values of 0.8, 0.2, 100, 2000 and 0.8, 0.5, 100, 2000 for crossover probability, mutation probability, population size, and number of generations are suggested as parameters for the selection and packing genetic algorithms respectively, and are used subsequently for solving the problem sets (except where otherwise stated).

Results and Comparisons Results for the problem sets are shown in Table 9 and Table 10 below. The best, worst and average-case computation time and weight utilization (shown as a percentage -26 -of the maximum weight a container can carry) achieved by the Load Optimization algorithm is shown for each problem set. This is based on performing 50 experiments on each problem set. The approximate best time and weight utilization achieved by the manual method is shown as well. Finally, the average time and weight utilization across all the 15 problem sets for all the methods considered is shown.

Results for Problem Sets The results show that the Load Optimization algorithm clearly achieves a higher weight utilization than the manual method for all the 15 problem sets. It is shown that the worst-case solutions obtained from the load optimization algorithm are consistently better than the solutions obtained from the manual method for all problem sets. We can also see that solutions are obtained in a reasonable time with the worst-case time of 21.91 seconds.

Table 9 Results for the 15 problem sets Problem Manual process Load Optimization algorithm sets Weight Approx Weight Utilization (%) Time (s) utilization Best (%) Time (s) Worst Average Best Worst Average Best PS (1) 98.15 300 100 100 100 0.53 0.49 0.47 PS (2) 98.72 300 99.94 99.99 100 11.72 0.70 0.46 Ps (3) 98.92 300 100 100 100 0.47 0.42 0.40 PS (4) 98.58 300 100 100 100 0.42 0.38 0.38 PS (5) 98.68 300 100 100 100 0.49 0.37 0.36 PS (6) 95.8 300 99.71 99.99 100 11.29 0.85 0.37 PS (7) 99.25 300 100 100 100 0.46 0.40 0.38 PS (8) 99.73 300 100 100 100 0.37 0.35 0.33 PS (9) 94.71 300 100 100 100 0.39 0.37 0.36 PS (10) 85.54 300 100 100 100 0.42 0.35 0.33 PS (11) 89.16 300 99.76 99.76 99.76 0.35 0.28 0.26 -27 -Problem Manual process Load Optimization algorithm sets Weight Approx Weight Utilization (%) Time (s) utilization Best (%) Time (s) Worst Average Best Worst Average Best PS (12) 95.43 300 100 100 100 0.36 0.33 0.32 PS (13) 94.88 300 99.99 99.99 99.99 0.34 0.31 0.31 P3(14) 81.60 300 99.99 99.99 99.99 0.34 0.31 0.30 PS (15) 96.52 300 98.75 99.96 100 21.91 2.10 0.37 Average 95.04 300 99.88 99.98 99.98 3.32 0.53 0.36 values Table 10. Results for the 15 problem sets with stacking constraints considered Problem Manual process Load Optimization algorithm sets Weight Approx Weight Utilization (%) Time (s) utilization Best (%) Time (s) Worst Average Best Worst Average Best PS (1) 98.15 300 99.99 100 100 1.35 0.34 0.28 PS (2) 98.72 300 94.36 99.33 100 48.17 25.28 0.28 PS (3) 98.92 300 99.99 100 100 0.29 0.27 0.25 PS (4) 98.58 300 99.22 99.98 100 97.40 2.29 0.23 PS (5) 98.68 300 90.42 99.45 100 226.86 23.40 0.24 PS (6) 95.8 300 78.29 99.07 100 175.78 29.10 0.24 PS (7) 99.25 300 94.34 99.2 100 158.73 38.36 0.24 PS (8) 99.73 300 78 96.55 100 293.53 78.59 0.21 PS (9) 94.71 300 99.93 99.99 100 177.86 3.79 0.22 PS(10) 85.54 300 93.17 99.25 100 301.34 75.70 0.22 PS (11) 89.16 300 99.76 99.76 99.76 1.86 0.67 0.22 PS (12) 95.43 300 99.91 99.97 100 0.25 0.22 0.21 PS (13) 94.88 300 99.77 99.96 99.99 0.23 0.21 0.20 PS (14) 81.60 300 96.28 99.63 99.95 345.56 33.34 0.19 -28 -Problem Manual process Load Optimization algorithm sets Weight Approx Weight Utilization (%) Time (s) utilization Best (%) Time (s) Worst Average Best Worst Average Best PS (15) 96.52 300 89.6 99.07 100 154.56 39.06 0.23 95.04 300 94.2 99.41 99.98 132.25 23.37 0.23 Comparisons with other Rectangle Packing Algorithms The packing algorithm is designed to be easily integrated with any rectangle packing algorithm. The CygonRectanglePacker selected for use in the packing algorithm is compared with two other rectangle packing algorithms, the SimpleRectanglePacker and the ArevaloRectanglePacker. The results in table 11 below show that the CygonRectanglePacker consistently outperforms the other two algorithms in both weight utilization and computation time.

Table 11. Results obtained for different rectangle packing algorithms Problem Rectangle Load Optimization algorithm sets Packing Algorithms Weight Utilization (%) Time (s) Worst Average Best Worst Average Best PS (1) SimplePacker 99.63 99.97 100 4.19 0.83 0.28 CygonPacker 100 100 100 2.93 0.50 0.28 ArevaloPacker 99.83 99.99 100 10.76 0.84 0.29 PS (2) SimplePacker 99.1 99.94 100 3.82 0.70 0.28 CygonPacker 100 100 100 0.33 0.30 0.28 ArevaloPacker 99.98 99.99 100 0.41 0.37 0.33 With regards to the weight utilization achieved, the CygonRectanglePacker perfoms better, consistently achieving a utilization of 100% for the worst-, best-and average-case scenarios for the two problem sets considered. The -29 -ArevaloRectanglePacker and SimpleRectanglePacker follow closely, with the ArevaloRectanglePacker producing a slightly better result than the SimpleRectanglePacker. With regards to computation time, the CygonRectanglePacker noticeably outperforms the other two algorithms in the worst-and average-case scenarios, with little or no difference in the best-case scenario.

Comparison with manual packing The results obtained compared to manual packing are displayed graphically in figures 9 and 10. Figure 8 shows a clear improvement in terms of load optimisation using the algorithms according to the invention and figure 10 shows that the algorithms have a computation far lower than the 10 minutes mentioned above, which itself is very optimistic -in practice, 30 minutes would be more typical. The data also shows a slight reduction in the weight utilization and a noticeable increase in computation time achieved by the load optimization algorithm when the stacking constraint is introduced in Load Optimisation algorithm 2. (Load Optimization Algorithm 1 represents the algorithm run on the normal problem sets whereas Load Optimization Algorithm 2 represents the algorithm run on the problem sets extended to consider the stacking constraint.

The performance obtained, is very acceptable and practical. As is particularly clear from figure 9, the best-and average-case performance of the algorithm produces better results than the manual method, with the worst-case performance producing results as good as those obtained by the manual method.

The quality of the weight utilization and computation time obtained does not seem to be affected by the characteristics of the problem set. The performance does not seem to be any better on problem sets with a high number of jobs/pallets than on problem sets with a low number of jobs/pallets. For some of the smaller problem sets, the weight utilizations obtained (e.g. 99.76% for Problem set 11), while not the maximum possible for the container, are found to be the best possible utilization that can be achieved -30 -considering the number of available jobs/pallets. In such cases, the algorithm obtains the best possible result without achieving a 100% utilization.

In summary, the results obtained from the tests performed on all the problem sets show that the approach produces results of much better quality than the existing manual methods used and runs in a reasonable amount of time.

Industrial applicability

In this description, a method has been disclosed which solves the selection part of the container loading problem. The method is tailored to meet the specific needs associated with packing engineering products, which are heavy. The method takes into consideration very practical constraints considered while loading pallets onto containers.

The output from the method can be used to run an automated robotic packing system.

The method of packing has been tested on real data. The results of the tests performed show that the algorithm achieves an average weight utilization of 99.98% in 0.53 seconds. With the introduction of a stacking constraint, the method achieves an average weight utilization of 99.41% in 23.37 seconds.

An embodiment of a system incoiporating the algorithm which carries out the method is shown in figure 11 and comprises a series of sales terminals 1, which are computer terminals 1 a to in into which sales operatives input the details of the job orders (i.e. job numbers and pallet groupings for each job) that should be released over a period, e.g. during a certain week or month. The sales terminals 1 are connected via a Wide Area Network (WAN) 2 to a Warehouse Management System (WMS) 3 and the data (details of the job orders) inputted into the sales terminals is transmitted via the WAN 2 and stored in the disk and memory of a database server (DB) 4. The WMS 3 also comprises an application server, from which applications are run.

The database server 4 also holds the physical location in the warehouse of the pallets. This information along with the pallet details for each pallet, i.e. the weight, height, length, breadth, pallet type and whether or not the pallet is stackable is input into -31 -packing terminals 6, which are computer terminals 6a to 6n. Note that the pallet type determines whether a pallet can be rotated or not. This information is transmitted via the WAN 2 and stored in the database of the WMS 3.

Transport terminals 7, which are computer terminals 7a to 7n, set up in a transport office include an intelligent system (IS) B which includes software incorporating the algorithm described above. The 1S8 retrieves the details of jobs released for e.g. the week or month from the WMS 3 and runs the container loading algorithm. Thus the IS generates a loading plan. Optionally, more than one loading plan may be output and a transport operative may select a loading plan. The loading plan which may simply be a list of the pallets to be loaded, but in the embodiment indicates specifically, which top pallets should be stacked on bottom pallets and show (e.g. graphically as in figure 7) the arrangement of the bottom pallets, is loaded and saved into the database 4 of the WMS 3 together with information specifying a container which will be loaded.

At this stage, in its simplest form, the loading plan may be printed out by a printer connected (e.g. via the WAN 2) to the WMS 3 or the transport terminals 7 and loaders may then load a container with the pallets in accordance with the loading plan.

In another embodiment, the loading plan is downloaded from the WMS 3 by loading terminals 9 which are computer terminals 9a to 9n incorporating a 3d graphical system (3DGS) comprising 3D graphical software. The 3D graphical software displays the loading plans graphically in a manner that can be interacted with in 3D, showing how the pallets will be loaded if the instructions in the loading plan are followed. These 3D plans may be printed along with the step-by-step instructions for loading the pallets into the container and loading may be carried out by loaders using e.g. fork-lift trucks or robots 10.

In another fully automated embodiment, the loading plans are downloaded from the WMS 3 by robot control terminals 11 which are computer terminals 1 la to 11 n including control software for controlling the movement of robots 10. The process of -32 -loading the containers may then be fully automated, with the robot control terminals 11 instructing the robots to pick specific pallets (based on location information downloaded from the WMS 3 indicating the location of the pallets in the warehouse), stack them and place them in the correct location in the container, as determined by the loading plan.

The robots 10 of figure 11 are shown in more detail in figure 12, in which a picking robot 12 runs along rails 13 and has an arm 14 used to pick up loads 15 consisting of palletized goods from their location in the warehouse. The picking robot 12 deposits the loads 15 in a transfer area 16 located close to a dock 17, where containers, e.g. shipping containers 18 are docked. A packing robot 19, running on rails 20 picks up the loads from the transfer area with telescopic arm 21, stacks them, in accordance with instructions received from the robot control terminals 11, in accordance with the loading plan and packs them into the container 18, again based on instructions received from the robot control terminals 11, in accordance with the loading plan.

It will be appreciated that the method for determining how to pack a container and the method of then packing a container in accordance with the determination as described herein may be modified by those skilled in the art without departing from the scope of the invention as defined by the appended claims. For example, whilst the CygonRectanglePacker was used in the example, other rectangle packing algorithms may be suitable and whilst a genetic algorithm was used to solve the knapsack problem numerous alternatives are known that could make the job selections based on the weight of the jobs. Similarly, whilst robots 10 with arms, running on rails have been described herein, the method could be used to control an automatic loader such as that described in US7967543 and whilst the method has been exemplified as software running on a PC, alternatively the method could be carried out by an application specific integrated circuit, or a field programmable gate array.

-33 -

Table 12

Problem Set #1 Pallet number Weight L B H JOB0001/00001 381 120 81 78 JOB0001/00002 487 105 75 61 JOB0001/00003 597 105 75 73 JOB0001/00004 380 105 75 56 JOB0001/00005 497 105 75 69 JOB0001/00006 279 80 70 81 JOB0001/00007 306 80 70 72 JOB0001/00008 655 120 81 69 JOB0001/00009 561 105 75 73 JOB0001/00010 810 105 75 72 JOB0001/00011 718 105 75 73 JOB0001/00012 325 105 75 56 JOB0001/00013 479 105 75 61 JOB0001/00014 228 80 70 72 JOB0001/00015 433 80 70 79 30B0002/00001 523 120 81 62 JOB0002/00002 699 120 81 74 JOB0002/00003 608 120 81 76 JOB0002/00004 551 120 81 76 30B0002/00005 648 120 81 88 30B0002/00006 662 120 81 77 JOB0002/00007 729 120 81 76 JOB0002/00008 503 120 81 76 JOB0002/00009 513 120 81 76 JOB0002/00010 852 120 81 78 30B0002/00011 353 80 70 71 JOB0002/00012 815 120 81 94 JOB0003/00001 176 80 70 45 JOB0003/00002 362 80 70 74 30B0003/00003 358 80 70 74 JOB0003/00004 296 80 70 74 JOB0003/00005 614 80 70 74 30B0003/00006 467 120 81 60 JOB0003/00007 227 80 70 58 JOB0004/00001 52 80 60 30 30B0005/00001 577 105 75 87 30B0005/00002 577 105 75 87 30B0005/00003 46 80 60 36 JOB0006/00001 66 80 60 28 30B0007/00001 551 120 81 72 JOB0007/00002 564 120 81 73 JOB0007/00003 508 80 70 75 30B0007/00004 459 80 70 75 JOB0007/00005 282 80 70 75 JOB0007/00006 351 80 70 75 J0B0007/00007 378 80 70 75 30B0007/00008 393 80 70 84 -34 -Pallet number Weight L B H JOB0007/00009 412 80 70 96 JOB0007/000l0 447 80 70 75 30B0007/00011 498 80 70 75 JOB0007/00012 349 80 70 86 30B0007/00013 393 80 70 81 JOB0007/00014 329 80 70 80 JOB0007/00015 563 120 81 70 J0B0007/00016 618 105 75 70 30B0008/00001 400 105 75 63 30B0008/00002 204 80 70 49 JOB0008/00003 163 80 70 66 JOB0009/0000l 360 80 70 77 JOB0009/00002 241 80 70 75 JOB0009/00003 363 80 70 73 30B0009/00004 372 80 70 73 JOB0009/00005 337 80 70 73 JOB0009/00006 549 105 75 71 J0B0009/00007 406 80 70 72 30B0009/00008 331 80 70 72 JOB0009/00009 543 105 75 72 30B0009/00010 342 80 70 76 JOB0009/00011 464 80 70 73 JOB0009/00012 303 80 70 76 30B0009/00013 757 105 75 83 JOB0009/00014 387 80 70 72 J050009/00015 340 80 70 72 JOB0009/00016 298 80 70 72 JOB0009/00017 735 105 75 84 JOBOO1O/00001 294 80 70 74 JOBOO1O/00002 592 105 75 71 JOBOO1O/00003 391 80 70 92 JOBOO1O/00004 279 80 70 72 JOBOO1O/00005 401 120 81 76 JOBOO1O/00006 495 105 75 69 JOBOO11/00001 308 80 70 81 JOBOO11/00002 296 80 70 81 JOBOO11/00003 418 80 70 73 JOBOO11/00004 522 105 75 72 JOBOO11/00005 693 105 75 86 JOBOO11/00006 336 80 70 79 JOBOO11/00007 633 105 75 75 ]OBOU11J0000S 590 105 75 79 JOBOO11/00009 600 105 75 71 JOBOO11/00010 600 105 75 71 JOBOO11/00011 599 105 75 71 JOBOO11/00012 345 80 70 63 JOBOO11/00013 503 105 75 61 JOBOO11/00014 600 105 75 71 JOBOO11/00015 534 105 75 72 JOBOO11/00016 740 105 75 71 JOBOO11/00017 435 80 70 73 JOBOO12/00001 292 80 70 58 -35 -Pallet number Weight L B H JOBOO12/00002 700 120 81 60 JOBOO12/00003 676 120 81 76 30B0012/00004 816 120 81 76 JOBOO12/00005 503 120 81 60 30B0012/00006 601 80 70 92 JOBOO12/00007 700 120 81 76 JOBOO12/00008 660 120 81 76 J0B0012/00009 661 120 81 92 30B0012/00010 292 80 70 73 30B0012/000l1 407 80 70 69 JOBOO12/00012 619 120 81 76 JOBOO12/00013 459 120 81 61 JOBOO13/00001 268 80 70 64 J0B0013/00002 515 105 75 72 30B0013/00003 552 105 75 73 JOBOO13/00004 555 105 75 72 J0B0013/00005 346 105 75 47 J0B0013/00006 264 105 75 69 30B0013/00007 416 105 75 58 JOBOO13/00008 403 105 75 58 30B0013/00009 261 80 70 76 JOBOO13/00010 371 80 70 95 JOBOO13/00011 156 80 70 60 30B0013/00012 549 120 81 76 JOBOO14/00001 776 105 75 81 J050014/00002 332 105 75 56 JOBOO14/00003 418 80 70 99 JOBOO14/00004 553 105 75 65 JOBOO14/00005 352 80 70 73 JOBOO14/00006 450 105 75 56 30B0014/00007 261 80 70 64 JOBOO14/00008 500 105 75 56 JOBOO14/00009 924 105 75 85 30B0014/00010 440 105 75 56 JOBOO14/00011 653 105 75 70 JOBOO14/00012 322 80 70 74 J0B0014/00013 393 80 70 91 30B0014/00014 310 80 70 66 JOBOO15/00001 316 80 70 74 JOBOO15/00002 331 80 70 74 30B0015/00003 308 80 70 74 ]0B0015J00004 281 80 70 71 JOBOO15/00005 296 80 70 73 JOBOO15/00006 441 80 70 89 JOBOO15/00007 347 80 70 74 JOBOO15/00008 317 80 70 74 J0B0015/00009 319 80 70 74 30B0015/00010 154 80 70 51 JOBOO15/00011 400 80 70 74 JOBOO15/00012 258 80 70 59 30B0015/00013 366 80 70 74 JOBOO15/00014 184 80 70 67 -36 -Pallet number Weight L B H JOBOO1S/00015 345 80 70 74 JOBOO1S/00016 343 80 70 74 30B0015/00017 349 80 70 74 JOBOO15/00018 368 80 70 73 30B0015/00019 276 80 70 73 JOBOO15/00020 276 80 70 73 JOBOO1S/00021 74 80 70 39 J0B0016/00001 309 80 70 79 30B0016/00002 282 80 70 66 30B0016/00003 306 80 70 78 JOBOO16/00004 499 105 75 59 JOBOO16/00005 617 105 75 71 JOBOO16/00006 418 105 75 59 JOBOO16/00007 238 80 70 79 30B0016/00008 420 105 75 59 JOBOO16/00009 619 105 75 71 JOBOO16/00010 628 105 75 74 J0B0016/00011 617 105 75 71 30B0016/00012 479 105 75 59 JOBOO16/00013 605 105 75 71 30B0016/00014 279 105 75 71 JOBOO16/00015 196 80 70 49 JOBOO16/00016 783 105 75 71 30B0016/00017 645 105 75 73 JOBOO17/00001 737 105 75 82 J050017/00002 736 105 75 82 JOBOO17/00003 737 105 75 82 JOBOO17/00004 409 80 70 84 JOBOO17/00005 355 80 70 83 JOBOO17/00006 402 80 70 83 30B0017/00007 640 105 75 81 JOBOO17/00008 656 105 75 81 JOBOO17/00009 316 105 75 72 30B0017/00010 733 105 75 82 JOBOO17/00011 732 105 75 82 JOBOO17/00012 212 80 70 77 J0B0017/00013 231 80 70 73 30B0017/00014 584 105 75 83 JOBOO17/00015 416 105 75 72 JOBOO18/00001 616 105 75 72 30B0018/00002 600 105 75 72 ]0B0018J00003 125 80 60 46 JOBOO18/00004 361 80 70 84 JOBOO18/00005 472 80 70 92 JOBOO18/00006 352 80 70 82 JOBOO18/00007 583 105 75 71 J0B0018/00008 680 105 75 73 30B0018/00009 370 80 70 83 JOBOO19/00001 335 80 70 83 JOBOO19/00002 444 80 70 83 30B0019/00003 307 80 70 73 JOBOO19/00004 825 120 81 82 -37 -Pallet number Weight L B H JOBOO19/00005 315 80 70 81 JOBOO19/00006 286 80 70 76 30B0019/00007 250 80 70 72 JOBOO19/00008 389 120 81 83 30B0019/00009 683 105 75 82 JOBOO19/00010 484 105 75 63 JOBOO19/00011 230 105 75 41 J0B0019/00012 441 105 75 71 30B0019/00013 696 105 75 82 30B0019/00014 75 80 70 43 JOBOO2O/00001 193 80 70 60 JOBOO2O/00002 363 105 75 61 JOBOO2O/00003 394 80 70 82 JOBOO2O/00004 254 80 70 62 30B0020/00005 484 105 75 62 JOBOO2O/00006 594 105 75 77 JOBOO2O/00007 212 80 70 60 J0B0020/00008 189 80 70 65 30B0020/00009 446 105 75 56 JOBOO2O/00010 539 105 75 65 30B0020/000l1 613 105 75 75 JOBOO2O/00012 608 105 75 72 JOBOO2O/00013 598 105 75 72 30B0020/00014 208 80 60 66 JOBOO2O/00015 555 105 75 70 J050020/00016 559 105 75 72 JOBOO21/00001 599 120 81 74 JOBOO21/00002 709 105 75 72 JOBOO21/00003 708 105 75 72 JOBOO21/00004 341 80 70 89 30B0021/00005 620 105 75 72 JOBOO21/00006 641 105 75 72 JOBOO21/00007 563 120 81 67 30B0021/00008 663 105 75 71 JOBOO21/00009 639 105 75 72 JOBOO21/00010 522 105 75 71 J0B0021/00011 329 80 70 73 30B0021/00012 227 80 70 76 JOBOO21/00013 291 80 70 76 JOBOO21/00014 291 80 70 51 30B0021/00015 348 80 70 78 ]0B0021J00016 506 80 70 76 JOBOO21/00017 586 105 75 71 JOBOO21/00018 328 80 70 82 JOBOO21/00019 518 105 75 71 JOBOO21/00020 494 80 70 76 J0B0021/00021 353 80 70 73 30B0021/00022 234 80 70 76 JOBOO21/00023 260 80 70 73 JOBOO21/00024 234 80 70 73 30B0021/00025 331 80 70 73 JOBOO21/00026 378 80 70 76 -38 -Pallet number Weight L B H JOBOO21/00027 354 80 70 87 J0B0022/00001 279 80 70 85 30B0022/00002 290 80 70 85 J0B0022/00003 325 80 70 84 30B0022/00004 237 80 70 74 J0B0022/00005 355 80 70 88 J0B0022/00006 350 80 70 96 J0B0022/00007 348 80 70 78 30B0022/00008 396 80 70 84 30B0022/00009 331 80 70 79 J0B0022/00010 358 105 75 67 J0B0022/00011 317 80 70 74 J0B0022/00012 398 80 70 85 J0B0022/00013 394 80 70 84 30B0022/00014 398 105 75 61 J0B0022/00015 399 80 70 84 J0B0022/00016 362 120 81 78 J0B0022/00017 528 105 75 91 30B0023/00001 679 120 81 90 J0B0023/00002 783 105 75 86 30B0023/00003 188 80 70 62 J0B0023/00004 742 105 75 71 J0B0023/00005 268 80 70 58 30B0023/00006 334 80 70 79 J0B0023/00007 656 105 75 85 J050023/00008 308 80 70 83 J0B0023/00009 725 105 75 84 J0B0023/00010 726 105 75 84 J0B0023/00011 399 80 70 88 J0B0023/00012 348 80 70 72 30B0023/00013 348 80 70 72 J0B0023/00014 176 80 70 44 J0B0024/00001 435 80 70 92 30B0024/00002 614 105 75 76 J0B0024/00003 263 80 70 57 J0B0024/00004 317 80 70 78 J0B0024/00005 642 105 75 77 30B0024/00006 306 80 70 79 J0B0024/00007 502 80 70 92 JOBOO2S/00001 324 80 70 79 30B0025/00002 443 80 70 90 ]0B0025J00003 433 80 70 82 J0B0025/00004 323 80 70 59 JOBOO2S/00005 795 120 81 75 J0B0025/00006 573 105 75 82 JOBOO2S/00007 666 120 81 79 J0B0025/00008 602 105 75 76 30B0025/00009 620 105 75 68 JOBOO2S/00010 586 105 75 71 J0B0026/00001 477 80 70 87 30B0026/00002 341 105 75 47 J0B0026/00003 601 105 75 70 -39 -Pallet number Weight L B H J0B0026/00004 578 105 75 74 J0B0026/00005 442 80 70 94 30B0026/00006 848 105 75 89 J0B0026/00007 268 80 70 71 30B0026/00008 336 80 70 76 J0B0026/00009 232 80 70 72 J0B0027/00001 670 105 75 75 J0B0027/00002 281 105 75 66 30B0027/00003 368 105 75 83 30B0027/00004 534 105 75 71 J0B0027/00005 455 105 75 71 J0B0027/00006 371 80 70 78 J0B0027/00007 280 105 75 66 J0B0027/00008 535 105 75 71 30B0027/00009 596 105 75 71 J0B0027/00010 595 105 75 71 J0B0027/00011 534 105 75 71 J0B0027/00012 504 105 75 76 30B0027/00013 536 105 75 71 J0B0027/00014 386 105 75 87 30B0027/00015 364 80 70 79 J0B0027/00016 201 80 70 46 J0B0028/00001 281 80 70 92 30B0028/00002 400 80 70 67 J0B0028/00003 778 105 75 71 J050028/00004 209 80 70 62 J0B0028/00005 359 80 70 83 J0B0028/00006 339 80 70 84 J0B0028/00007 460 80 70 94 J0B0028/00008 403 105 75 87 30B0028/00009 311 105 75 71 J0B0029/00001 169 80 70 59 J0B0029/00002 306 80 70 76 30B0029/00003 875 120 81 76 JOBOO3O/00001 359 80 70 75 JOBOO3O/00002 486 80 70 88 J0B0030/00003 630 105 75 80 30B0030/00004 516 105 75 70 JOBOO3O/00005 651 105 75 74 JOBOO3O/00006 464 105 75 74 30B0030/00007 490 105 75 60 ]0B0030J00008 379 105 75 57 JOBOO3O/00009 291 80 70 73 JOBOO31/00001 237 80 70 61 JOBOO31/00002 352 80 70 72 JOBOO31/00003 443 105 75 64 J0B0031/00004 702 105 75 83 30B0031/00005 476 80 70 96 JOBOO31/00006 335 80 70 73 JOBOO31/00007 581 105 75 79 30B0031/00008 391 105 75 65 JOBOO31/00009 607 105 75 64 -40 -Pallet number Weight L B H J0B0032/00001 238 80 70 77 J0B0032/00002 412 105 75 69 30B0032/00003 613 105 75 79 J0B0032/00004 217 80 70 64 30B0032/00005 198 80 70 59 J0B0032/00006 389 80 70 76 J0B0032/00007 309 80 70 79 J0B0032/00008 358 80 70 66 30B0032/00009 341 80 70 75 30B0033/00001 14 80 60 31 J0B0034/0000l 36 80 60 29 JOBOO3S/0000l 220 120 81 38 J0B0036/0000l 370 80 70 59 J0B0036/00002 880 105 75 92 30B0036/00003 536 105 75 71 J0B0036/00004 580 120 81 72 J0B0036/00005 812 105 75 70 J0B0036/00006 304 80 70 76 30B0036/00007 800 105 75 70 J0B0036/00008 798 105 75 70 30B0036/00009 348 80 70 64 J0B0036/00010 288 80 70 63 J0B0037/00001 325 80 70 77 30B0037/00002 458 80 70 87 J0B0037/00003 937 105 75 85 J050037/00004 340 80 70 88 J0B0037/00005 280 105 75 71 J0B0037/00006 229 105 75 51 J0B0037/00007 983 105 75 85 J0B0037/00008 513 105 75 57 30B0037/00009 709 105 75 70

Claims (23)

1. -41 -Claims: 1. A method of electronically optimising packing of items in a container comprising: I) inputting data representing: a) jobs consisting of one or more items which must be shipped together; b) the dimensions of each item; c) the weight of each item; d) whether each item can support another item; ii) running a selection algorithm to select job selections for populating the container by maximising the sum of the weight of jobs within the threshold of the weight capacity of the container and sorting the job selections according to their fitness; üi) running a stacking algorithm on the fittest job selection to create a set of stacks of items, the stacks comprising either a bottom item alone or a stack of at least two items comprising a top item supported by the bottom item; whereby the stacks of at least two items are maximised, such that the total number of stacks in the set is minimised, wherein the total height of each stack is no higher than the maximum allowed height of the container, and in any stack of at least two items, the bottom item can support another item and the length and breadth of the top item is less than or equal to the length and breadth of the bottom item; iv) running a packing algorithm to determine whether the stacks can be packed into the container based on the dimensions of each bottom item; and v) if all the stacks can be packed in the container, outputting the list of items to be packed into the container.
2. 2. A method according to claim 1 wherein if the stacks cannot be packed into the container, the stacking algorithm and the packing algorithm are run on the next-fittest job selection, until ajob selection is obtained that can be packed completely on the -42 -container floor, and then a list of the items for that successful packing arrangement is outputted.
3. 3. A method according to claim 1 or 2 wherein the container is a shipping container.
4. 4. A method according to claim 1 or 2 wherein the container is a trailer or the cargo bay of a fixed-body lorry.
5. 5. A method according to any of the preceding claims wherein the items are palletized goods.
6. 6. A method according to claim 5 wherein the palletized goods are palletized boxes of goods.
7. 7. A method according to any of the preceding claims wherein the stacking algorithm ensures that the weight of each top item is less than the weight of each bottom item.
8. 8. A method according to any of the preceding claims wherein the list of items to be packed into the container is displayed graphically.
9. 9. A method according to claim 8 wherein the list of items is displayed graphically as a 3D representation of the items in the container.
10. 10. A method according to any of the preceding claims wherein the selection algorithm is presented as a one-dimensional knapsack problem in which the container represents the knapsack, the jobs represent the items to be selected and the value of an item is the total weight of the items in the job.
11. 11. A method according to claim 10 wherein if a plurality of job selections have the same maximum weight, the selection algorithm selects the job with the maximum volume utilisation.
12. 12. A method according to any of the preceding claims wherein the selection algorithm is a genetic algorithm -43 -
13. 13. A method according to any of the preceding claims wherein the stacking algorithm is a greedy algorithm.
14. 14. A method according to any of the preceding claims wherein the stacks consist of either a bottom item alone or a stack of only two items consisting of a top item supported directly on top of the bottom item.
15. 15. A method according to any of claims ito 13 wherein the stacks of at least two items consist of stacks of a bottom item alone, stacks of only two items, consisting of a top item supported directly on top of the bottom item and stacks of three or more items consisting of a top item supported on top of the bottom item by one or more intervening items wherein the length and breadth of each item in the stack is less than or equal to the length and breadth of the item directly beneath it.
16. 16. A method according to any of the preceding claims wherein the packing algorithm is an order based genetic algorithm integrated with a rectangle packing algorithm.
17. 17. A method according to claim 16 wherein the rectangle packing algorithm is the CygonRectanglePacker.
18. 18. A method according to any of the preceding claims wherein the method is implemented using a computer.
19. 19. A method according to any of the preceding claims further comprising the step of packing a container with the items identified in the output.
20. 20. A method according to claim 19 wherein packing is carried out by robots.
21. 21. A method according to claim 20 wherein the robots are controlled by a controller operating in accordance with the output from the method of any of the preceding claims.
22. 22. A control circuit for robots comprising the method of any of the preceding claims.-44 - 23. A method according to any of the preceding claims further comprising the steps of inputting data representing whether each item has a fixed orientation in the container; and wherein the packing algorithm takes into account whether each bottom item has a fixed orientation when determining whether the stacks can be packed into the container.24. A method according to any of the preceding claims wherein at least one job consists of a plurality of items which must be shipped together and wherein in the step of running the selection algorithm, jobs are only selected to populate the container when all the items in said job are included in the job selection.25. A computer programmed to carry out the method of any of the preceding claims.26. A computer program which carries out the method of any of claims 1 to 24.27. A computer readable medium programmed to carry out the method of any of claims ito 24.28. An application specific integrated circuit or field programmable gate array programmed to implement the method of any one of claims 1-24 Amendments to the Claims have been filed as follows Claims: 1. A method of packing items in a container using an electronic optimisation method comprising: I) inputting data representing: a) jobs consisting of one or more items which must be shipped together; b) the dimensions of each item; c) the mass of each item; d) whether each item can support another item; ii) running a selection algorithm to identify job selections for populating the container having a total mass within the threshold of the weight capacity of the container, and sorting the job selections according to their fitness, wherein fitness is the total mass of the job selection with a higher fitness having a higher total mass IC) iii) running a stacking algorithm on the fittest job selection to create a set of C) stacks of items, the stacks comprising either a bottom item alone or a stack of at least two items comprising a top item supported by the bottom item; whereby the stacks of at least two items are maximised, such that the total number of stacks in the set is minimised, wherein the total height of each stack is no higher than the maximum allowed height of the container, and in any stack of at least two items, the bottom item can support another item and the length and breadth of the top item is less than or equal to the length and breadth of the bottom item; iv) running a packing algorithm to determine whether the stacks can be packed into the container based on the dimensions of each bottom item; v) if all the stacks can be packed in the container, outputting the list of items to be packed into the container; and vi) packing the items into the container in accordance with the list.2. A method according to claim 1 wherein if the stacks cannot be packed into the container, the stacking algorithm and the packing algorithm are run on the next-fittest job selection, until ajob selection is obtained that can be packed completely on the container floor, and then a list of the items for that successful packing arrangement is outputted.3. A method according to claim 1 or 2 wherein the container is a shipping container.4. A method according to claim 1 or 2 wherein the container is a trailer or the cargo bay of a fixed-body lorry.5. A method according to any of the preceding claims wherein the items are palletized goods.6. A method according to claim 5 wherein the palletized goods are palletized boxes of goods.7. A method according to any of the preceding claims wherein the stacking algorithm ensures that the mass of each top item is less than the mass of each bottom C) item.8. A method according to any of the preceding claims wherein the list of items to be packed into the container is displayed graphically.9. A method according to claim 8 wherein the list of items is displayed graphically as a 3D representation of the items in the container.10. A method according to any of the preceding claims wherein the selection algorithm is presented as a one-dimensional knapsack problem in which the container represents the knapsack, the jobs represent the items to be selected and the value of an item is the total mass of the items in the job.11. A method according to claim 10 wherein if a plurality of job selections have the same maximum mass, the selection algorithm selects the job with the maximum volume utilisation.12. A method according to any of the preceding claims wherein the selection algorithm is a genetic algorithm 13. A method according to any of the preceding claims wherein the stacking algorithm is a greedy algorithm.14. A method according to any of the preceding claims wherein the stacks consist of either a bottom item alone or a stack of only two items consisting of a top item supported directly on top of the bottom item.15. A method according to any of claims ito 13 wherein the stacks of at least two items consist of stacks of a bottom item alone, stacks of only two items, consisting of a top item supported directly on top of the bottom item and stacks of three or more items consisting of a top item supported on top of the bottom item by one or more intervening items wherein the length and breadth of each item in the stack is less than or equal to the length and breadth of the item directly beneath it.16. A method according to any of the preceding claims wherein the packing algorithm is an order based genetic algorithm integrated with a rectangle packing C) algorithm.17. A method according to claim 16 wherein the rectangle packing algorithm is the CygonRectanglePacker.18. A method according to any of the preceding claims wherein the method steps i) to v) are implemented using a computer.19. A method according to any preceding claim wherein the packing step is carried out by robots.20. A method according to claim 19 wherein the robots are controlled by a controller operating in accordance with the output from the method of any of the preceding claims.21. A control circuit for robots comprising the method of any of the preceding claims.22. A method according to any of claims ito 20 further comprising the steps of inputting data representing whether each item has a fixed orientation in the container; and wherein the packing algorithm takes into account whether each bottom item has a fixed orientation when determining whether the stacks can be packed into the container.
23. 23. A method according to any of claims ito 20 or 22 wherein at least one job consists of a plurality of items which must be shipped together and wherein in the step of running the selection algorithm, jobs are only selected to populate the container when all the items in said job are included in the job selection. IC) C?) r