A Framework for 3D Layout Solutions Representation using OpenGL Raymond Kuo Yang Soo1,2 and Yong Haur Tay2 1

Analytic Solutions Development (ASD), Intel Technology Sdn. Bhd., MALAYSIA. 2

Computer Vision and Intelligent Systems (CVIS) Group, Universiti Tunku Abdul Rahman (UTAR), MALAYSIA. [email protected], [email protected]

Abstract

Many researchers had worked on three dimensional (3D) optimization which presented results using numbers and graphs. This paper proposes a standard way to represent the solution naturally, in 3D graphical layout display based on OpenGL. Since container loading problem (CLP) is a common reference for 3D space optimization algorithms, we present a method to represent the 3D layout solution for CLP. This paper aims to benefit researchers which would like to utilize 3D graphics to represent their solution and outcome from their optimization algorithms. With a prototype introduced as a proof of concept for this framework proposed, this paper will serve as a guide for the implementation of this framework to many CLP optimization algorithms.

1. Introduction 1.1

Background and objective

This paper addresses the problem of having a standard 3D graphical representation framework for 3D layout optimization solutions representation. A simple definition of 3D layout optimization in general may be to state 3D layout problem as a difficult task in organizing or arranging multiple types and instances of objects into a larger dimension location. A very good example to be used to describe the problem is the well known container loading problem (CLP) where the problem is to arrange and place multiple types and instances of boxes into a container. Other alternative for 3D layout solutions may be to arrange objects that are to be stored in a store-room, in a warehouse or to have an optimize factory layout to place the machines in the most efficient manner. In this paper, we will use the popular CLP 3D layout optimization problem statement as a base to build this framework. We propose a programming framework

utilizing Visual Studio.NET technologies and OpenGL to be used for this 3D graphical representation. The programming framework here will propose a way to represent 3D layout for CLP solutions in a user-friendly way.

1.2

Motivation

The proposed framework is based on the earlier work of Bischoff [1]. One effective way of representing the solution as discussed in his paper was using two different matrices. Both of these matrices play important roles in helping the optimization algorithm suggested in his work. Matrix 1 contains the information needed to identify potential loading surfaces. Matrix 2 is structured in an equivalent manner. Here in Matrix 2, the cells for the different floor sections is indicating the load bearing ability of the associated surface. The algorithm then utilizes these two matrices to determine the search route [1]. In summary, this shows that the data representation may help in speeding up or guiding the algorithms for optimization. Other works [2, 3, 4, 5, 6, 7, 8] presented statistical results for solving CLP and also worked on problems with multiple containers. Some included diagrams for representing the solution/state for their techniques used respectively. For this case, the proposed framework can be implemented with their final solution’s state suggested by their algorithms in the end as well.

2. High-level description of the proposed framework 2.1 Assumptions and data representations In this section we will discuss in general about our proposed framework. The framework consists of a few

classes to represent objects for CLP. There are certain assumptions based on Bischoff’s [1] definitions of CLP. i.e: • Objects to be placed in the container are made out of boxes and only cubes & cuboids objects. • Each container can have a few types of boxes with different dimensions to be placed into it. • Each type of boxes can have more than one occurrence (multiple instances of the boxes.) Based on these assumptions made, we can clearly see the main component or class that needs to be used in representing a state or a solution in this search space optimization problem. We define the class to represent the objects of boxes. This will be discussed in details in the next section. We also see that we need two tables to represent the problem for multiple container loadings. Therefore we will define the data table for the two levels of data representation. A container will have a set of box types assigned to be loaded into it. Therefore we will use the container as a parent table that will be referred by the box table. The details will be further discussed in next section as well.

2.2 Prototype development as a proof of concept

Figure 1: Diagrams quoted from Bischoff [1] showing the matrices’ data and 3D state view of the boxes placed in one particular container. With the data representation defined, we then have a prototype tool developed to represent the problem discussed in [1]. The state shown in Figure 1 was able to be simulated in our prototype solution to show it in a flexible 3D view using the framework proposed in this discussion. The prototype was developed with the purpose to show as a proof of concept that the framework concept can be implemented on one of the algorithms developed for 3D layout optimization problem. The details will be discussed in the next section of this paper.

3. Detailed framework architecture 3.1 Framework components In this section we will describe the details on the components of the framework and its architecture. First, we define a class for the box objects using a VB.NET file utilizing the Visual Studio.NET as our base tool for defining object oriented components. Class: Boxes -length As Integer -width As Integer -height As Integer -weight As Double -lbaLen As Double -lbaWid As Double -lbaHei As Double +lengthI As Boolean +widthI As Boolean +heightI As Boolean +X As Integer +Y As Integer +Z As Integer +Cid As String +Bid As String +topOcc As Boolean +sideOcc As Boolean +frontOcc As Boolean +belowbid As String +behindbid As String +besidebid As String +New() +New(len As Integer, wid As Integer, hei As Integer) +getLength() +getWidth() +getHeight() +setLength(len As Integer) +setWidth(wid As Integer) +setHeight(hei As Integer) +GetLBALength() +GetLBAWidth() +GetLBAHeight() +setLBALength(lba As Double) +setLBAWidth(lba As Double) +setLBAHeight(lba As Double) +GetWeight() +setWeight(weiVal As Integer) +setWeight(weiVal As Double) +setWeight() +overrides ToString() As String +getPosition() As String +rotateX() +rotateY() +rotateZ()

Figure 2: Sample class diagram for the Box object implementation from the VB.NET file.

Figure 2 shows all the attributes and methods needed to define a box object. • The attributes length, width & height show the 3 main dimension of the box’s size. • The attributes lengthI, widthI & heightI is used to assist any algorithms that may want to consider if the box type can be placed in a different orientation against its height’s dimension or against its length’s dimension or width’s dimension. • The attributes X, Y & Z are used to determine where the box is placed in the container to show the coordinates of the box’s location in the container. • Meanwhile, weight shows how heavy the box weigh and lbaLen, lbaWid & lbaHei shows the load bearing ability of the box meaning how much weight can it support on top of it if it is placed in the length orientation or width orientation or height orientation respectively. • Cid & Bid are the unique identifier for the box object and to which container it is to be loaded to. • Then, topOcc, sideOcc & front Occ shows whether any box occurs either on top of the box or in front of the box or at the side of it to determine the placement of boxes and its arrangement to help assist some algorithms to better determine the current state of arrangements of the boxes in certain containers. • Finally, the belowbid, behindbid & besidebid is used to show the exact box that was placed below, behind or beside this box before the box is placed to further assist the visibility for the representation of the arrangement of boxes in the containers. We then define also two tables to represents boxes objects and containers objects. We also define their relationship as a (1:M) one-to-many relationship. We use MS ACCESS database as the base to build our database for our prototype development. MS ACCESS was chosen simply due to its simplicity to implement and due to there is no need for highly complex data security needed.

Figure 3: Screenshot of the MS ACCESS database table for boxes.

Figure 4: Screenshot of the MS ACCESS database table for containers. Figure 3 shows the data table attributes defined for the objects of boxes. The Primary Key (PK) will be a composite key which is a combination of boxID and containerID in short (BID & CID) respectively. Figure 4 shows the data table attributes defined for the objects of containers. The PK will be the ContainerID (CID). The CID in the earlier table therefore acts as a Foreign Key (FK) for it.

3.2 Prototype’s detailed descriptions The prototype developed as mentioned earlier is a sample of solution that utilizes the framework concept introduced here. The prototype was developed using Microsoft Visual Studio.NET implementing the box class defined earlier. The display utilizes openGL scripts to allow dynamic view of the 3D representation.

Figure 5: Example screenshot of the prototype.

Figure 5 shows a sample user interface (UI) that can be designed to use the framework for solution representation. The openGL scripts will be called by clicking the “View results in 3D” button instantiating the 3DView interface form class.

Figure 7: Adjusted 3D representation to simulate state in figure 1. The 3DView window is called using the codes shown below: Figure 6: Screenshot for UI of 3DView class. When instantiating the 3DView class, a data table was pass into the constructor as an input parameter. This data table was passed from the data table that is displayed in the data grid object in the prototype’s main interface under the “Coordinate” table at the bottom of the UI. It takes only the necessary attributes from the boxes to be passed into the input parameter. Form column 1 to 6 (boxNo, X, Y, Z, Length, Width & Height). These data are used in the 3DView class to represent how the boxes are to be shown in the 3D space using openGL scripts. The 3DView interface as shown in figure 6 provides few features to rotate the 3D diagram in X, Y and Z axes. Also there are features to zoom in and zoom out the diagram. Each box is colored accordingly and given black edges to show the edges in order to distinguish them from other placed boxes. In order to simulate the diagram shown in figure 1, we rotate the diagram using the features to give a UI showing as in figure 7:

Private Sub btnView3D_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnView3D.Click Dim dtRes As New DataTable Try dtRes = dgCoor.DataSource Dim frm3d As New ThreeDview(dtRes) frm3d.Show() Catch ex As Exception MessageBox.Show("Error: unable to show results in 3D," & vbCrLf & "Details: " & ex.Message, "Failed") End Try End Sub

“ThreeDview(dtRes)” that was instantiated for “frm3d” object, is a customized constructor for the form class defined for the 3DView window. “dtRes” is the data table passed as the input parameter into the 3DView window.

4. Contributions This framework contributes a user-friendly interface for all CLP research works which uses the same assumptions of the constraints on the boxes to be placed into the containers. The flexibility is there to allow different kinds of results in the output table as long as the main data “boxNo”, “X”, “Y”, “Z”, “length”, “width” & “height” is there in the first 6 columns of the table. Additional columns are simply used to guide algorithms evaluation or just to describe the arrangement of the boxes further. This framework therefore can be used across multiple techniques and methodologies of solving 3D layout problems which are similar to CLP. The advantage of this framework is it only requires programmers to pass in the minimum required data to the 3Dview window form. They only need to format in the data table with the first six columns filled according to the format defined. The

disadvantage here is that the framework is not yet platform independent as it was developed in .NET framework and thus requires to be implemented in .NET technologies. The framework contributes to researchers who are interested to use a 3D graphical representation to show the solutions from their algorithms. Therefore, they can spend more of their focus on the algorithms and simply utilize this framework as their base for solution representation in 3D graphics.

5. Conclusion and Future Works This paper shows that a standard 3D layout representation for CLP problems is possible. This paper provides a general framework that can be used across multiple types of CLP solution methods researched by various groups to represent their solution in a userfriendly manner. It eases their work where now they only need to focus more on designing the efficient optimization algorithms and just use the framework to implement with the algorithms to effectively represent their results or solutions in 3D graphics. However further works needs to be done to make it standard across all other 3D layout problems. Currently it is able to cater for only 3D layout problems which are similar to CLP definition meaning objects to be placed are in boxes shapes (cubes & cuboids). The future works from here on is to continue to try out different algorithms’ implementation of this framework. The prototype developed here is to show a proof of concept on the implementation of an output generated from a heuristic/local search technique used in [1]. Similar techniques were also found in Fukunaga & Korf [3], Andrew & Xingwen [4], Liu et al [5], Moura & Oliveira [6] and Miyamoto et al [8]. Future works may include evolutionary computing methods in solving the same problem that was used in Raidl’s [2] and Takahara & Miyamoto [7]. Also, another direction for future works may be to further research on additional useful features for UI or classes for other objects with shapes other than cubes & cuboids to be added into the framework. This may help to even generalize the framework more for flexibility to be implemented across various techniques and methodologies used to solve a more general 3D layout problem other than CLP. Future researchers may also want to use the similar concept of this framework to be developed in other programming platforms like JAVA and so on to make the framework concept portable to any platform and remove the dependencies on .NET technologies.

6. Acknowledgement Special thanks to Bischoff for sharing his datasets and algorithms, which motivates our research discussion. We would also like to thank the reviewers from CVIS Group, UTAR to help revising this manuscript.

7. References [1] E. E. Bischoff, “Dealing with load bearing strength considerations in container loading problems”, EBMS Working Paper EBMS/2003/3, European Business Management School, U.K, 2003. [2] G. R. Raidl, “The Multiple Container Packing Problem: A Genetic Algorithm Approach With Weighted Codings”, Institute of Computer Graphics, Vienna University of Technology, Vienna, Austria, 1999. [3] A. S. Fukunaga and R. E. Korf, “Bin-Completion Algorithms for Multicontainer Packing and Covering Problems”, Computer Science Department, University of California, Los Angeles. [4] A. Lim and X. Zhang, “The Container Loading Problem”, ACM Symposium on Applied Computing, ACM, Hong Kong, 2005. [5] Y. Liu, Y. Tian and T. Sawaragi, “A Heuristic Algorithm Based on DBR and MAS for Solving Container Loading Problem”, IEEE, Japan, 2006. [6] A. Moura and J. F. Oliveira, “A GRASP Approach to the Container-Loading Problem”, Transportation & Logistic IEEE Intelligent Systems, IEEE Computer Society, Porto, Portugal, 2005. [7] S. Takahara and S. Miyamoto, “An Evolutionary Approach for the Multiple Container Loading Problem”, Proceedings of the Fifth International Conference on Hybrid Intelligent Systems (HIS’05), IEEE Computer Society, Japan, 2005. [8] S. Miyamoto, K. Hanzawa, Y. Endo and Y. Hamasuna, “An optimization system for container loading based on metaheuristic algorithms”, University of Tsukuba, Ibaraki 305-8573, Japan.