An envelope generation algorithm for packing and layout applications

Int J Interact Des ManufDOI 10.1007/s12008-014-0216-5

ORIGINAL PAPER

An envelope generation algorithm for packing and layoutapplications

Santosh Tiwari · Georges Fadel · Peter Fenyes ·Artemis Kloess

Received: 12 September 2011 / Accepted: 20 March 2014© Springer-Verlag France 2014

Abstract In this paper, an algorithm and associated pro-cedure for computing the envelope of non-convex manifoldobjects is proposed. The envelope generation algorithm isdeveloped in the context of vehicle packaging and layoutand is intended for use during the conceptual phase of thevehicle design process. The envelope generation algorithmpresented in this paper is designed to work with complexmanifold geometry and can be interpreted as the non-convexhull of an object (or a set of objects). The algorithm presentedin this paper is primarily intended for probabilistic envelopegeneration based on spatial occupancy, however it can alsobe used to generate the envelope of a set of objects, envelopewith a desired offset from the outer surface of the object,and motion envelope of an object. The proposed method isbased on voxelization of the manifold geometry and thus itconverts surface representation into volumetric representa-tion to generate the envelope. The proposed envelope gen-eration algorithm is demonstrated on sufficiently complexhypothetical geometries and a real-world application of theproposed algorithm to vehicle occupant packaging is pre-sented. This proposed envelope generation algorithm canreduce the design time and automate certain aspects of thevehicle design process.

S. Tiwari (B) · P. Fenyes · A. KloessGeneral Motors Company, Warren, MI 48090, USAe-mail: [email protected]

P. Fenyese-mail: [email protected]

A. Kloesse-mail: [email protected]

G. FadelClemson University, Clemson, SC 29634, USAe-mail: [email protected]

Keywords Envelope Generation · Occupant Packaging ·Spatial Occupancy · Probabilistic Envelope

1 Introduction

Vehicle packaging is key to the early phases of the vehicledevelopment process. Space must be allocated for the vehiclecomponents, the occupants, and their belongings. The shapeand size of many parts and sub-assemblies used in a vehicleare dictated by the available space and other application spe-cific requirements. It is thus desired to compute a geometricrepresentation of the space available to package a componentas well as a geometric representation of the space occupiedby it. In the context of vehicle interior layout, a geometricrepresentation of the envelope of the occupants in the vehi-cle is often needed as a constraint during the interior layoutdesign. Also, it is often desired to provide clearances betweendifferent vehicle components (e.g. minimum specified clear-ance between the exhaust pipe and the body of the vehicle)and clearances between the occupants and the componentsin the interior of the vehicle (minimum specified head-room,knee clearance, shoulder room etc.). Furthermore, in the con-text of vehicle design, uncertainties in certain vehicle com-ponents (e.g. the vibration of suspension and other compo-nents) and external (e.g. size of the occupants) parameters arealso involved. Instead of designing a vehicle for the worst-possible scenario (overly conservative design), it is commonpractice to address a subset of possible scenarios (e.g. 95 %of occupants should fit comfortably in the vehicle or 99 %of the time the suspension components should be within aspecified range) and thus probabilistic envelope of certaincomponents is required. In this paper, an envelope genera-tion algorithm that takes into account the probabilistic aspectof spatial occupancy of vehicle components and occupants

123

Int J Interact Des Manuf

is presented. The availability of such envelopes facilitatesthe decision making process. Such an envelope also encap-sulates the internal details of a geometry and thus allowsfor significantly faster CAD operations like collision detec-tion, volume assessment, and generation of proof-of-conceptassemblies. Another characteristic of the envelope generationprocess proposed in this paper is its fully automated nature; itdoes not require any human intervention or input during theenvelope generation process. Hence, the proposed methodcan be integrated with the existing work-flow and would notin any way hamper the automated design and analysis.

A classification of different types of envelopes is presentedfirst. Based on the characteristics of the desired envelope, itcan be divided into the following two categories.

1. Deterministic envelope: In this case, a non-convex enve-lope of the object is desired. The non-convex envelopeof an object need not be unique, and thus the smallestnon-convex envelope that encapsulates the object com-pletely is desired. This envelope must encapsulate all theinternal geometric details of the object and should be amanifold.

2. Probabilistic envelope: In this case, there is variabilityin the shape, size, location, and number of objects. Thisvariability is often characterized by temporal and spatialoccupancy which must be taken into account during theenvelope generation process. The algorithm presented inthis paper is suitable for this type of envelope.

For both the types mentioned above, there are four kinds ofenvelopes that are typically desired:

1. Envelope of a single object: This is the simplest case anda non-convex envelope that hides (encapsulates) all thedetailed internal geometry of an object is desired. Thistype of envelope can be used in place of the originalobject in applications that only require the outer skin ofthe object. An example of this case is the engine block.Suppose it is desired to place certain components (e.g.fluid reservoirs) around the engine block. For such anoperation, only a representation of the outer surface ofthe engine block is required—the unnecessary internaldetails of the engine are not needed during the layoutdesign process. It should be noted that if the CAD datais properly formulated, the designer should be able to“turn off” the inside details. However, this is not alwayspossible in practice.

2. Envelope of a moving object: This is also called motionenvelope or swept volume generation. In this case, anenvelope is desired such that the object always remainsinside the generated envelope throughout its motion. Anexample of this case is the suspension assembly whichundergoes significant motion w.r.t. the vehicle frame. No

other object can be placed in the region which can poten-tially be occupied by a suspension assembly. Thus, in thiscase the generated envelope must encompass the rangeof the motion of the suspension assembly.

3. Offset envelope: In this case, an envelope is desired thathas the specified offset from the outer skin (surface) ofthe object. The offset is typically specified in a directionnormal to the skin surface at a point. This type of envelopeis encountered in many scenarios where clearances arerequired. The clearances may be needed for assembly,maintenance, or safety reasons. Furthermore, clearancesare almost always required when computing the envelopeof occupants in a vehicle.

4. Envelope of a set of objects: In this case, an envelope isdesired that encapsulates a set of objects. Thus the enve-lope in this case represents the outer surface of the unionof the set of objects. An example of this case is the gen-eration of occupant space claim (OSC) during the designof the interior of the vehicle. Since occupants in a vehiclevary in their size and the vehicle has to be designed for agiven population segment, the generated envelope mustencompass the prescribed population segment. Anotherexample is the envelope of a sub-assembly which con-tains multiple components.

The probabilistic envelope generation algorithm proposedin this paper is developed in steps. It can be used to generateenvelopes for all the scenarios discussed above and does notrequire any human intervention during the envelope gener-ation process. In this paper, it is demonstrated that an algo-rithm capable of generating a probabilistic envelope of a setof objects can be used to generate an envelope for all thescenarios discussed above; however it may not be the bestalgorithm (most efficient and accurate) for each case. Analgorithm to generate a deterministic envelope of a singleobject is proposed first. It is then extended to generate anenvelope of a set of objects; which is subsequently used togenerate a motion envelope. Finally, it is further extended totake into account the spatial occupancy.

The envelope generation algorithm proposed in this paperis based on the idea of voxels [1–3]. A complete descriptionof the basic voxel algorithms used in this paper can be foundin [3]. The surface data of the objects is imported in form ofSTL files. The STL (Stereolithography) format describes thesurface of an object as a collection of triangles in 3D space.Thus, the surface geometry used here is in the tessellatedform. Most CAD software can output the surface geometryas STL files and thus use of this format does not restrict theapplication of this algorithm to a specific CAD software. Theenvelope generation process converts the surface data intovolumetric data via voxelization. Ray tracing algorithms arethen used to classify the voxels based on whether they are out-side, on the surface, or inside the object. The voxels that are on

123


the surface are then used to generate a point cloud representa-tion of the envelope. A suitable mesh generation algorithm isthen used to generate a mesh from the point cloud. A methodto generate the surface mesh directly from the voxel data isalso mentioned in this paper. For the case of probabilisticenvelopes, the spatial occupancy (defined in the followingsections) is recorded in each voxel. This spatial occupancyis used to generate the point cloud taking into account thedesired probability. The accuracy (maximum error) of theenvelope generation method proposed in this paper is depen-dent on the voxel size used to represent the volumetric data.

In Sect. 2, a brief survey of the existing literature on enve-lope generation is presented. Section 3 contains the descrip-tion of the algorithm to compute the deterministic envelopeof a single object. Sections 4, 5, and 6 discuss the exten-sion of the proposed algorithm to the envelope of a set ofobjects, generation of the offset envelope, and motion enve-lope respectively. In Sect. 7, the proposed method is fur-ther extended to account for the probabilistic nature of thegenerated envelope. Sections 3 to 7 also contain demonstra-tions of the proposed method on hypothetical geometries. InSect. 8, a real-world application of the proposed algorithmis presented. Finally in Sect. 9, inferences, conclusion, andpossible future work are presented.

2 Literature survey

The envelope of an object is mathematically defined onlyfor closed geometries. If the geometry is not closed, thenthe envelope of the geometry is itself. Mathematically, anypoint on the surface of the object that can be reached fromoutside the object constitutes the envelope; thus the envelopeis the union of all such points. Hence, the envelope gen-eration process is concerned with determining a geometricrepresentation of the surface that contains all such points.Envelope generation is known by many names dependingupon the specific application and the desired characteristicsof the generated envelope. When the envelope of an objectmoving through space is desired, it is referred to as sweptvolume of the object [4]. A comprehensive and detailed sur-vey on swept volume generation can be found in [5]. Theswept volume generation is encountered in many industrialapplications such as robot motion planning [6], machiningoperations [7], and determining occupant space claim [8].In [9], an efficient algorithm for generating the swept vol-umes of complex polygonal models moving along a smoothtrajectory is proposed. When the envelope of a set of mani-fold objects is desired, a Boolean union of those objects canbe performed to get the desired envelope. Often, the infor-mation about the geometry is available as a point cloud. Insuch a case, a non-convex hull of the point cloud can be gen-erated using the alpha-shape method [10]. The alpha-shape

is a generalization of the non-convex hull, and the level ofdetail in the generated envelope can be controlled by vary-ing the value of α. For α = 0, the alpha-shape of the pointcloud is the point cloud itself. For α = ∞, the alpha-shapeof the point cloud is the convex hull of the point cloud. Theintermediate levels of detail can be obtained by choosing avalue of α in (0,∞). The alpha-shape gives the approximateshape of a point cloud. The suitable value of α is typically thesmallest value that produces a single connected shape. Theimplementations of the alpha-shape method however are notvery reliable, and often suffer from degeneracy issues. Apartfrom the alpha-shape, there exist many other algorithms togenerate a mesh from point-cloud data [11,12]. The methoddescribed in [11] works with arbitrary point cloud data anddoes not require the approximate normals at those points. Itgenerates an adaptive spherical cover corresponding to thepoints and is based on local quadric error minimization strat-egy. It requires the point cloud to be piecewise smooth. Thismethod is robust and generates an excellent surface mesh,however if the noise in the data set is higher than a threshold,holes are created in the surface mesh. The method describedin [12] is referred to as Poisson Surface Reconstruction. Thismethod requires the approximate normals at the points andis very reliable. It almost always generates a correct meshwithout any holes or cavities, but it fails to capture the sharpedges and features if any.

In this paper, the mesh based surface representation is con-verted to voxels which is converted to point cloud from whichthe final surface mesh is generated. This method of enve-lope generation however has one fundamental disadvantage.The topological information is lost during the conversion topoint cloud, and hence the surface mesh obtained may nothave the same connectivity between different nodes. It ispossible to generate a surface mesh directly from the voxeldata using the marching cubes algorithm [13]. The march-ing cubes algorithm extracts the ISO-surface from the voxeldata. To generate a surface envelope, all the voxels that areeither inside or on the surface can be assigned a specificISO-value (say 255) and the remaining voxels which are out-side the envelope can be assigned a small value (say 0) andthen ISO-surface extraction can be performed. The march-ing cubes algorithm is very reliable and always generates acorrect surface mesh but it fails to capture the sharp features,and steps are generated in the surface mesh since it followsthe voxels exactly. Furthermore, the marching cubes algo-rithm generates surface meshes that have a large number oftriangles and thus coarsening of the surface mesh is almostalways required. Another approach to generate an envelopeof a set of objects is the shrink-wrap algorithm [14]. Thisalgorithm adaptively triangulates the iso-surface and is reli-able. It is however not suitable for the present applicationsince it cannot be extended to include the probabilistic infor-mation (spatial occupancy).

123


Before discussing the envelope generation algorithm, arational for the proposed approach is presented first. A carefulanalysis of the advantages and disadvantages of the existingtechniques for envelope generation helps in making appro-priate choices when designing the proposed algorithm.

• Use of volumetric representation: Certain envelope gen-eration algorithms like shrink-wrap [14] do not com-pletely rely on volumetric representation and alsomaintain the topological connectivity of the original sur-face mesh. Such methods however cannot account forthe desired spatial occupancy and therefore cannot beextended to generate a probabilistic envelope.

• Use of voxels instead of octrees: Octrees are in gen-eral more efficient than voxels in terms of memoryusage. Both data structures can store a volumetric rep-resentation of a model. However, when computing theenvelope of a set of objects, boolean union operationsare more expensive (and cumbersome) with octrees ascompared to voxels. A union of two octrees involvesdetermining overlapping cubes of different sizes andrefinement/consolidation as part of the union operation;whereas a union of two voxelated models is trivial in thatthe union contains all voxels that are present in either ofthe models.

• Use of mesh generation from point cloud as opposed tofeature sensitive surface extraction: Feature sensitive sur-face extraction [9,15] techniques give a more accuratesurface envelope since they can capture features (edges).However, these techniques rely on the existence of sur-face normals to generate features. When generating adeterministic envelope (envelope of a set of objects ormotion envelope), surface normals can be computed, thusexisting techniques will result in an envelope that cap-tures the features. However, a probabilistic envelope neednot lie on or near the surface of the objects, hence thenormals are not available, and therefore such techniquescannot be used.

• Generation of point cloud data instead of marching cubesalgorithm: The marching cubes algorithm [13] can gen-erate a triangulated surface directly from the voxel (volu-metric) data and can also take into account the ISO level(mapped to spatial occupancy in this paper) of voxels.The primary disadvantages of the marching cubes algo-rithm are that it introduces steps in the surface envelopeand generates a large number of triangles. It was foundthat the point cloud data generated from the voxel matrixresulted in higher quality surface meshes with signifi-cantly smaller number of triangles. It also did not resultin steps.

• Spatial occupancy: The voxels denote a region in spaceand are aligned on a regular 3D matrix. Each point inspace can thus be associated with a voxel. The presence

of a voxel implies that the corresponding region in spaceis occupied. If multiple objects occupy the same regionin space, this information can be recorded in a voxel (thenumber of objects occupying that voxel). In this paper, thespatial occupancy of a point is defined as the frequencyof it being occupied by the objects for which the envelopeis desired. Thus, the spatial occupancy (the probability)can be directly represented in terms of the ISO level of avoxel. This benefit is not provided by any other methodmentioned in the literature. This makes voxels an idealchoice for probabilistic envelope generation. Also, sincethe voxel data is volumetric, it is trivial to classify thevoxels based on whether they are inside, on the surface,or outside the surface envelope. Voxels are thus ideallysuited for point classification. Voxels also allow for easyBoolean (union) operations which is needed in the case ofenvelope generation for multiple or moving objects. Thedownside of using voxels is the accuracy of the generatedenvelope which depends on the voxel size.

We now discuss the proposed envelope generation algo-rithm and gradually introduce it in the following sections.

3 Deterministic envelope of a single object

In this section, the basic algorithm to generate the envelopeof single manifold object is presented. The input to the enve-lope generation algorithm is an object in tessellated form andthe output is a manifold geometry also in tessellated formthat encapsulates the object. The envelope does not containany internal details of the object. It also does not containany topological and/or topographical information about theobject. For the proposed algorithm to work, the object mustbe closed and all the triangles that constitute its surface musthave a non-zero area. It however does not require the trianglesto have correct normals as it does not use this information.The generated envelope is an approximation to the surfacewhich is defined as the collection of all points on the surfaceof the object that can be reached from outside the object. Theenvelope generation algorithm consists of four steps whichare as follows.

1. In the first step, the surface data is converted into volumet-ric data using surface voxelization algorithm described in[3].

2. In the second step, ray tracing from multiple directionsis used to classify all the voxels depending upon whetherthey are inside, on the surface, or outside the envelope.

3. In the third step, point cloud data is generated from thevoxels that lie on the surface of the desired envelope.

4. In the fourth step, a suitable mesh generation algorithmis used to construct a surface mesh from the point cloud.

123


The obtained surface mesh is the approximation to thedesired surface envelope. Optionally the obtained surfacemesh may be post-processed to refine/coarsen the meshand remove the noise.

It is imperative to ask as to why the point cloud data is notdirectly generated from the surface mesh of the object itself.The following are the reasons as to why the data is convertedinto voxels.

• Most mesh (from point cloud) generation algorithmsrequire the point cloud data to be fairly smooth and freefrom any noise. If the noise in the point cloud data is ofthe same order as the spacing between the points, then itis difficult to assess the curvature of the surface passingthrough those points.

• Most mesh generation algorithms require the point cloudto have an almost uniform (or gradually changing) dis-tribution of points in order for them to generate a highquality surface mesh. If the distribution of points is irreg-ular, then it is difficult to identify the regions in space thatmust be included in the surface envelope. This limitationcan however be overcome by adaptive mesh refinement ofthe original geometry and voxelization is not mandatory.

• The most compelling reason to use voxelization is to iden-tify which points belong to the surface envelope, i.e. itrequires the classification and identification of all pointsthat lie on the surface (constitute the surface envelope).If the point cloud data is generated directly from the sur-face mesh of the object, then it would also include thepoints that are inside the surface. Such a point cloud ifprovided to a mesh generation algorithm will potentiallyresult in internal features which are not desirable. It willalso present difficulty to the mesh generation algorithmin determining which points to include for mesh genera-tion. Voxelization is one of the methods that can be usedfor point classification. There are other advantages ofusing voxels that are discussed in the following sectionsthat make it an appropriate choice for envelope genera-tion.

3.1 Surface voxelization

The surface voxelization used here is described in [3] andthus the following description is taken (verbatim) from [3].

The surface voxelization consists of following steps.

1. Compute the bounding box of the object.2. Construct a three dimensional matrix of voxels which

circumscribes the bounding box of the object.3. Determine the bounding box for every facet of the trian-

gulated object.

4. For every cell inside the bounding box of the facet, per-form a triangle-box overlap computation. If the facetintersects the cell, mark the cell as non-empty (occu-pied). The triangle-box intersection method proposed in[16] is used for this purpose.

3.2 Classification of voxels

The classification of the voxels using ray tracing consists ofthe following steps.

1. In the first step, all the voxels that are outside the objectare determined. To determine all the voxels that are out-side, parallel rays from all the six faces of the boundingbox are dropped. All the voxels that get illuminated areeither on the surface or outside the object. The voxels thatwere marked during the surface voxelization phase areclearly on the surface (or inside the object if the object hasinternal features) of the object, hence the remaining vox-els that are illuminated by the rays are outside the object.

2. It is possible that an object has blind holes or cavities;in such a case it is possible that a voxel which is outsidethe envelope may not get illuminated by the axis-alignedparallel rays. To determine all such voxels, every voxel ischecked for its neighbors. If a voxel is not on the surface(not marked) but has at least one neighbor that was illu-minated in step 1 then it can be reached from outside andthus is illuminated. This process is akin to diffusion ofrays. This process is repeated iteratively unless no suchvoxel that can be illuminated is found. After this step, allthe voxels that are outside have been identified.

3. In this step, the voxels that lie on the surface of the enve-lope are determined. Any voxel that is marked (during thesurface voxelization phase) and has at least one neighborthat is illuminated (is outside) is assumed to be on the sur-face of the envelope. These voxels are used to generatethe point cloud for the surface mesh.

4. This final step is optional for deterministic envelope gen-eration since all the surface voxels have been identifiedin the previous step. In this step, the voxels that arecompletely inside the envelope are determined. All theremaining voxels that are not outside or on the surfaceare simply assumed to be inside the surface envelope.

It can be clearly seen from the above algorithm that if theobject is not a manifold (closed), then the diffusion processwould cause the rays to illuminate all the voxels (exceptthose that are on the surface) and thus point classificationcannot be performed. Here, a voxel represents a point andthus to get an accurate envelope, extremely small voxel sizeis required.

123


3.3 Generation of point cloud data

Once the surface voxels have been identified, the point cloudgeneration process is trivial. The point cloud consists of thecentroid of all the voxels that are on the surface of the enve-lope. Since the mesh generation algorithm used in our caseinterpolates the points in the point cloud, the accuracy of thesurface envelope generation process is determined by thisstep. Let the size of the voxel be s units. We know that thetrue surface envelope passes through the voxel and the gen-erated point is located at the centroid of the voxel. Hence, inthe worst case the error (maximum deviation from the truesurface) is one-half of the longest diagonal inside the voxel.

Hence, the worst case error is√

3s2 units.

The typical size of vehicle components to which this algo-rithm is applied have the dimension of the order of 1 m. Thevoxel size used in our simulation has size 1 or 2 mm (≈ 10−3

m). Thus, the worst case error (maximum deviation) in thegenerated envelope is 0.1 % as compared to the size of theobject. If the bounding box of the object has the dimensions1 × 1 × 1 m3, then the total number of voxels required is109; i.e. 1 billion voxels. In our representation, each voxeltakes one byte of storage on a computer, requiring a total ofapproximately 1 GB of memory. The time taken by the enve-lope generation algorithm is of the order of few minutes. Forlarger objects, it is therefore recommended to increase thevoxel size or use a 64-bit computing architecture with suf-ficient memory. Since the number of voxels vary as a cubicfunction of the resolution used, the memory requirement aswell as the execution time vary as a cubic function of the gridresolution.

3.4 Mesh generation from point cloud

In this paper, we make use of the mesh generation algorithmproposed by Ohtake et al. [11]. The method proposed byOhtake et al. is based on the local quadric error minimiza-tion strategy [17]. It generates an adaptive spherical cover ofthe point cloud data. The adaptive spherical cover is then usedto generate the auxiliary points and the intersection betweenthe spheres is used to generate the connectivity information.The method proposed by Ohtake et al. removes any non-manifold triangles from the surface mesh and also includesmesh reconstruction, smoothing, and feature restoration. Fur-ther details of the method can be found in [11]. The meshgeneration algorithm takes as input the point cloud (the x, y,and z coordinates of each point) data and outputs a trian-gulated geometry. The obtained triangulated geometry is thedesired surface envelope. This algorithms allows to fine-tunethe accuracy of the surface mesh and it is possible that if veryhigh accuracy is desired, holes may be generated in the enve-lope (it outputs the number of holes in the generated mesh).

In such a case, it is recommended to increase the allowabletolerance till a manifold geometry is obtained.

A demonstration for this case is not presented since theenvelope of a single object will look like the object itself. Ademonstration for the envelope of a set of objects is presentedin the next section instead.

4 Deterministic envelope of a set of objects

It is fairly straight forward to extend the above describedalgorithm for the case of envelope of multiple objects. Theabove described algorithm has four steps: i) surface voxeliza-tion, ii) classification of voxels, iii) generation of point clouddata, and iv) mesh generation from the point cloud data. Togenerate an envelope of a set of objects, the surface voxeliza-tion step is modified. Surface voxelization of the same voxeldata (a 3D matrix) is performed with each object which isto be included in the envelope. This process is similar to theunion of voxel data where only surface voxels are present(marked). This process assumes that the union of two mani-fold objects is also a manifold object. Thus all the voxels thatare present on the surface of any of the objects are marked inthe first step. In this case however, each voxel is checked if itis already marked before performing triangle-box intersec-tion test. The time required to perform subsequent surfacevoxelizations generally reduces since many of the voxels arealready marked and no triangle-box intersection test is per-formed for those voxels. Also, the bounding box that con-tains all the objects is used to generate the voxel matrix inthis case. Once the surface voxelization step is completed,the remaining steps are identical to the above case.

4.1 Demonstration

A hypothetical case study involving three sufficiently com-plex free-form objects is presented to demonstrate the enve-lope generation process. The three objects are shown in Fig. 1.

The following simulation parameters are used to generatethe envelope.

• Average number of facets in the objects = 100,000• Voxel resolution = 2 mm• Number of voxels = 1,003×1,003×837 = 842,029,533• Dimension of the bounding box of the voxel grid =

2,006 × 2,006 × 1,674 mm3

• Number of surface voxels = number of points in the pointcloud = 7,264,502

• Number of facets in the generated surface envelope =643,972

• Total execution time = 5 min approx (with 1 mm voxelsize, the execution time is 30 min approx)

123


Fig. 1 The three objects

Fig. 2 The deterministic envelope

• Maximum deviation = 1.7 mm

The generated envelope is shown in Figs. 2 and 3.It is evident from the Figs. 2 and 3 that the proposed

method is capable of generating a usable surface envelope forsufficiently complex objects. The worst-case error (1.7 mmwith a voxel size of 2 mm) in this case is small enough com-pared to the size of the objects ( ≈ 2,000 mm). In appli-cations where a higher accuracy is desired, a smaller voxelsize is recommended. The obtained surface envelope can besignificantly coarsened to reduce the number of triangles.Quadric edge collapse decimation [18] is suggested to reducethe number of triangles in the generated envelope.

5 Motion envelope

In this section, we present the procedure to generate themotion envelope of a moving object. The motion of anobject is assumed to be specified as a transformation matrix.

Fig. 3 A cut-section of the envelope

Thus, the inputs to the envelope generation algorithm for thiscase are a manifold geometry (the object whose envelope isdesired) and a set of transformation matrices with an associ-ated time stamp. The time stamp information is not used bythe envelope generation algorithm. However, if the transfor-mation matrices are provided at different time intervals andif the object has moved significantly during those intervals,the time stamp information can be used to generate inter-mediate transformation matrices using linear interpolationbetween any two time stamps. To obtain a reasonably accu-rate motion envelope, it is suggested to use very small timesteps. In general, the smaller the time step used, the higheris the accuracy of the generated envelope. Thus, voxels areused to discretize the 3D space and time steps are used todiscretize the motion of the object.

The envelope generation algorithm described in the previ-ous section can be used for this case if an object (snapshot) isgenerated corresponding to each time step. It is not necessaryto generate multiple copies of the moving object, rather for

123


Fig. 4 The engine block

Fig. 5 Motion envelope of the engine block

each time stamp, the transformation matrix is multiplied bythe coordinates (also represented as a matrix) of the verticesof facets of the object and the surface voxelization is per-formed. In this case, it is required to perform all transforma-tions and compute the overall bounding box and the associ-ated voxel grid before starting the voxelization process. Thus,the motion envelope (swept volume) also can be generatedusing the same algorithm proposed for the deterministic enve-lope generation of a single object. It should however be notedthat this approach to generate a motion envelope need not bethe most efficient or the most accurate. Other approachessuch as the ones mentioned in [5,15] make use of the surfacenormals of the moving object and thus can replicate features(sharp edges) better. The approach presented here is useful if

probabilistic information should also be taken into accountwhilst generating the envelope.

5.1 Demonstration

A hypothetical engine block (shown in Fig. 4) is rotated by±15◦ about its centroid. The induced motion simulates thevibration of the engine block. The entire range of motionis discretized into 100 uniformly distributed time-steps. Thesimulation parameters (grid resolution) for this case are iden-tical to that of envelope generation of a set of objects. Thegenerated motion envelope is shown in Fig. 5. Total time ofexecution is 10 min approx.

6 Offset envelope generation

This type of envelope is required when clearance betweentwo objects is desired. An alternative to generating the offsetenvelope is to directly compute the clearance between a pairof objects. The clearance between a pair of non-intersectingmanifold objects can be defined as the shortest distance bywhich one object must be moved towards the other so thattheir surfaces collide. This requires computing not only thedistance but also the direction along which the distance mustbe computed. It is difficult and computationally expensive tocompute the clearance between two arbitrary objects. If thedesired clearance is known, and if an envelope is generatedwith the desired clearance as the offset, then a simple colli-sion detection (which is significantly less expensive) can beperformed between the objects to determine if the clearancesare satisfied. The offset envelope of only one of the objects isrequired to determine the clearances. Furthermore, if differ-ent clearances are required for different regions, multiple off-set envelopes with specified clearances can be generated andinterference check can be performed with the requisite off-set envelope. Also, the envelope generation is required onlyonce and during subsequent iterations of the design process,only collision checks are required. The offset envelope can bemathematically defined as the envelope of all surface patchesgenerated by a sphere with the diameter as the desired off-set rolling on the surface of the object for which the offsetenvelope is desired.

A method to generate the offset surface is proposed in[19,20]. The method proposed in [19] generates the offsetsurface by translating the vertices along the outward nor-mals. The outward normal at a vertex can be computed asthe weighted average of the normals of all the triangles thatcontain this vertex. The area of the triangles can be used asweights. This raw offset can potentially generate a geome-try with self-intersecting facets (Fig. 6) and sharp featuresmay appear or disappear (Fig. 7) during the offset process.In [21], a method is proposed to remove self-intersection.

123


Fig. 6 Self-intersecting geometry

Fig. 7 Sharp edges disappear

Thus, a combination of approaches proposed in [19,21] canbe used to generate a desired offset envelope. The processof removal of self-intersection however suffers from degen-eracy issues and therefore is not reliable. Furthermore, theresultant geometry may still contain internal features sinceit only generates the offset surface and does not attempt toremove hidden internal geometry. Hence, after the raw off-set is done, we instead suggest to generate a deterministicenvelope of the offset surface. The deterministic envelopegeneration process (described in Sect. 3) will remove self-intersection and internal features and will produce a manifoldgeometry. Generation of raw offset does not induce any error.Thus, the error in this case is only due to the deterministicenvelope generation process. And hence, the maximum errorin this case is identical to that of Sect. 3.

6.1 Demonstration

A hypothetical horse geometry is used to demonstrate theoffset envelope generation process. The horse geometry andits vertex normals are shown in Figs. 8 and 9 respectively.Identical simulation parameters as in the first example areused in this case. The generated offset envelope is shown inFigs. 10 and 11.

Fig. 8 The horse geometry

Fig. 9 The vertex normals

Fig. 10 The offset envelope

123


Fig. 11 Close-up of the offset envelope

7 Probabilistic envelope generation

The use of a deterministic envelope for components thattranslate/rotate or for a large number of similar componentsis a conservative approach, since it generates an envelope tak-ing into account all the scenarios (which includes the worst-case scenario). Often times, during the layout design of avehicle, it is desired to consider only the probable scenarios,and not include extremely low probability cases. Such a con-sideration has the potential to generate better solutions. Forexample, if clearance between two components is satisfied99 % of the time, the design may still be acceptable. Anothervery common example is the generation of occupant spaceclaim (space reserved for vehicle occupants—this space can-not be utilized by any of the vehicle components). There islarge variation in human anthropometry and it is extremelyinefficient to design a vehicle that can comfortably accom-modate the smallest as well as the tallest humans. Typicallythe interior space of a vehicle is designed to comfortablyaccommodate a prescribed segment (generally it is from 5thpercentile female to 95th percentile male) of the population.Discarding the extreme scenarios (cases) results in a moreefficient vehicle layout.

Developing an envelope generation algorithm that has thecapability to discard the extremely low probability cases (ifthis information is available) is the primary contribution ofthis paper. The deterministic envelope generation processdescribed in Sect. 3 is modified to generate a probabilisticenvelope. The deterministic envelope can be considered aspecial case of the probabilistic envelope where every voxelthat is occupied at least once is included in the surface enve-lope.

To generate a probabilistic envelope, there must be at leasttwo objects if an envelope of a set of objects is desired or two

snapshots in time if motion envelope is desired. To generatea probabilistic envelope, the concept of density is introducedand superimposed with the voxel matrix. The density is inter-preted in terms of the spatial occupancy of the object(s) forwhich the probabilistic envelope is desired. Since the voxel isa volumetric representation of the geometry, the region occu-pied by the voxels can be recorded. Each object or snapshotin time is treated as a frame by the voxelization engine. Sup-pose there are 100 frames (snapshots in time or number ofobjects) for which a probabilistic envelope is desired, and agiven voxel is occupied (present) by 95 of the frames then itsspatial occupancy is 95 %. Thus, if a 95th percentile envelopeis desired, then all the voxels that are occupied at least 95 %of the time are used to generate the point cloud data. Thus,each voxel in this case also records the number of frames thatoccupy it.

In standard volume processing software (e.g. Edtips andVolView), this spatial occupancy is referred to as the ISOlevel. The ISO level varies from 0 to 255 (256 values—thus each voxel requires one byte of storage), and hence amaximum of 256 snapshots can be recorded. If this con-vention is followed whilst recording the spatial occupancythen the resultant volumetric data can be visualized andprocessed in standard volume processing software. Hence,in this research, we limit the number of ISO levels to 256(a maximum of 255 snapshots are allowed; the ISO-levelof zero corresponds to the complete absence of a voxel).In most cases, the number of snapshots available are signifi-cantly less than 255. In such a case, the ISO levels are linearlyscaled to match the minimum (0) and maximum (256) values.Another limitation of this approach is that only discrete ISOlevels are recorded (95th percentile envelope correspondsto an ISO level of 95*256/100 ≈ 243). This discretization(into 256 levels) limits the fidelity of the probabilistic datathat can be recorded, and thus the maximum error in theprobability is 0.4 % which is acceptable for most applica-tions for which this algorithm is developed. If a higher levelof fidelity is desired, then the data type can be modified;however in such a case it may not be possible to visualizethe volumetric data with existing volume processing soft-ware.

The following modifications are performed to the deter-ministic envelope generation algorithm to incorporate proba-bilistic information. Instead of using one byte for each voxel,two bytes are used in this case. The first byte records the usualvoxel data (identical to the deterministic case) and the sec-ond byte records the ISO level (number of times it is occu-pied). Initially, all the voxels are marked empty (assigneda value of zero) which implies that they are not occupiedby any of the objects. The deterministic envelope generationinvolves four steps: i) surface voxelization, ii) classificationof voxels, iii) generation of point cloud, and iv) mesh gen-eration. The most time consuming operation is the second

123


step (classification of voxels) since it involves multiple raytracing operations. The surface voxelization identifies onlythe surface voxels. Ray tracing is required to convert thesurface voxels into true volumetric data (all the voxels thatare either inside or on the surface of the object are consid-ered to be occupied by that object). Thus, for each object(time stamp), the surface voxelization followed by classi-fication of voxels is performed. After these two steps, allthe voxels that are occupied are identified. Then, the ISOlevel of each voxel that is occupied is incremented by one.Once the ISO levels are updated, the primary voxel matrix(first byte) is reset (all the voxels are marked empty) andthis process is repeated for all the objects (frames). Once thefinal ISO levels are recorded, then all the voxels that havethe ISO level greater than or equal to the desired probabilityare marked present. Ray tracing algorithms are used onceagain to classify the voxels, and then the point cloud is gen-erated.

There are a few issues that arise during the probabilisticenvelope generation process which are discussed below.

• Connectedness of the generated envelope: It is desirableto obtain a single connected surface envelope which isa manifold. If there exists great disparity in the spatialoccupancy of different voxels, then the obtained pointcloud data can represent multiple disconnected regions.Suppose that the voxels having high ISO values (say99 % spatial occupancy) are physically present in twodifferent regions of the voxel matrix, and that the regionbetween those extremes is sparingly occupied, then theobtained envelope will be disconnected. In such cases, thedisconnectedness can be mitigated by choosing a smallenough ISO value that results in a connected envelope.An example where a scenario like this might occur isthe probabilistic motion envelope of a simple pendulum.A simple pendulum spends relatively more time at theextremes (has smaller velocity) and less time at its mid-dle (equilibrium) point (has the fastest velocity). Fur-thermore, in the case of a simple pendulum, the range ofmotion is significantly larger than the size of the object,a high ISO value (say 255) will result in a null envelopesince no region is occupied by the pendulum 100 % ofthe time.

• The anti-aliasing of the voxel grid: For a visually correctsurface envelope, it is desired to have a non-zero thick-ness throughout. When voxels are pruned based on theirISO value, they no longer follow the surface profile of theactual objects and it is possible to generate a voxel matrixwith zero thickness. In such a case, additional voxels inthe immediate vicinity are deliberately marked presentto avoid zero thickness. This process is demonstrated inFig. 12.

Fig. 12 The anti-aliasing of the voxel grid

Fig. 13 Angle as a function of time

7.1 Demonstration

The same hypothetical engine block used for the determin-istic motion envelope is used in this case. The engine blockundergoes a sinusoidal motion, and its orientation (angle) asa function of time is plotted in Fig. 13. It can be noticedfrom Fig. 13 that the engine block is present at its extremelocations most of the time. Hence, the spatial occupancy inthis case is higher at the extremes. The gray-coded pictureof the probabilistic envelope is shown in Fig. 14. In Fig. 14,the dark gray color corresponds to an ISO-level of 256 and

the very light gray color corresponds to an ISO-level closeto zero. Using an ISO level of 256 will result in an envelopethat will almost never contain the complete engine block (avery small subset of voxels have 100 % spatial occupancy).Furthermore, reducing the ISO level will result in chippingaway the volume from the mean (default) position which alsois not desirable. This effect is demonstrated in Fig. 15 for asmall section of the engine block with 85 % desired spatialoccupancy. In Fig. 15, the facets correspond to the probabilis-tic envelope and the mesh corresponds to the deterministicenvelope. In this case, it is recommended to use a low spa-tial occupancy (ISO level 1 which implies all the voxels thatare present at least once are included in the envelope) whichwould result in the envelope shown in Fig. 5. The simulationparameters for this case are identical to that of the deter-ministic envelope. It takes approximately 1 h to generate the

123


Fig. 14 The probabilistic envelope for the engine block

Fig. 15 Section of an 85 % probabilistic envelope

probabilistic (non-deterministic) envelope since surface vox-elization and ray tracing are performed for each time stamp.A more practical example where a probabilistic envelope isdesirable is presented in the next section.

7.2 Usability of the generated envelope and spatialoccupancy

The spatial occupancy of a voxel is defined as the frequencyof it being occupied by the objects/configurations for whichthe envelope is desired. Suppose 95th percentile envelope isdesired and there are a total of 100 configurations. Then anyvoxel which is present in at least 95 of the 100 configurationsis assumed to be included in the probabilistic envelope or inother words all the voxels that are occupied less than 5 timesare discarded. It should be noted that the voxels included inthe probabilistic envelope need not correspond to the sameset of 95 configurations, but different voxels may correspondto a different set of 95 frames. Hence, it is possible in certaincases that there may not exist a set of 95 frames which can becompletely accommodated in the generated envelope, eventhough the envelope corresponds to 95 % spatial occupancy.This proposed algorithm is intended to be used in scenar-ios where little overlap/interference is allowed with very lowprobability. An application of this algorithm to one such sce-nario is presented in the next section.

8 An application of the probabilistic envelopegeneration algorithm

The probabilistic envelope generation algorithm is appliedto the vehicle occupant packaging and is used to determinethe occupant space claim (OSC). The OSC is often used as aconstraint to determine the interior layout of a vehicle. In thispaper, OSC is defined as the region (volume) occupied by theseated mannequin. A mannequin is a computer model of ahuman which has identical anthropometric parameters. Forthis example, the mannequin is seated in the neutral drivingposture as predicted by the Ramsis posture prediction tool.Thus, a geometric model of the mannequin in neutral drivingposture is obtained using Ramsis as shown in Fig. 16.

This geometric model is used as the reference (constraint)during the interior layout and to compute the clearances (head

Fig. 16 Mannequin in neutral driving posture

123


Fig. 17 Voxelated model of a mannequin

Fig. 18 The ISO plot of the probabilistic envelope

room, shoulder room etc.), comfort rating, and visibility.This exercise is typically repeated for a given number ofmannequins with varying anthropometry representing a pre-scribed population segment. Instead of repeating this exer-cise multiple times for every mannequin, an envelope of allthe mannequins can be used to compute the desired vehicleparameters. Such an envelope would however always reportthe worst-possible values and hence will result in a conserv-ative design. For example if 25 mm headroom is desired,it will result in an interior layout where the tallest man-nequin has 25 mm clearance. Similarly, it can also resultin an overly designed seat travel box since the smallest aswell as the tallest individuals will have comfortable posture

Fig. 19 Probabilistic envelope of a set of mannequins

Fig. 20 40 % spatial occupancy

(joint angles, pressure distribution etc.). An automobile istypically designed to account only for a probable set of sce-narios and discarding the most extreme cases often resultsin significantly better designs. Hence, a probabilistic enve-lope (with specified clearances) is desired. The algorithmproposed in this paper is ideally suited to compute suchenvelopes. A human mannequin has bounding box dimen-sions under 2×1×1m3. Thus if a voxel resolution of 1 mm isused, the probabilistic envelope generation algorithm wouldrequire approximately 4 GB of memory to store the voxeldata (it is therefore recommended to use a 64 bit machine)and the worst-case error would be 0.87 mm. For the currentexample, a voxel size of 2 mm is used which reduces thememory requirement by 1/4th and the worst case error is1.7 mm which is acceptable for most practical applications.A low resolution voxel model of the mannequin is shown inFig. 17. 31 mannequins with varying anthropometry are usedto generate the probabilistic envelope. The ISO density plotof the probabilistic envelope is shown in Fig. 18. The gen-erated envelope is shown in Fig. 19. The contour plots fordifferent occupancy levels are shown in Figs. 20, 21, 22 and

123




23. In Figs. 20, 21, 22 and 23, the 100 % spatial occupancy isdenoted the by the blue colored line (outer border), and thered colored line denotes the percentage spatial occupancy.The total simulation time for this case is approximately 1 h.

9 Inferences, conclusion, and future work

In this paper, we have proposed a reliable algorithm and asso-ciated procedure to generate a probabilistic envelope of non-convex objects. The proposed method can generate enve-lope for a wide variety of cases including objects undergoingmotion, a set of distinct objects, envelope with a desired off-set, and probabilistic envelope based on spatial occupancy.The proposed method does not suffer from degeneracy issuesand is capable of working with complex geometries. Theproposed method is fully automated (it does not require anyhuman intervention during the envelope generation process)and can be integrated with the vehicle design process. Theuse of the generated envelopes instead of the actual geome-


tries can help in significantly faster CAD operations andalso eliminate the repetitive computations required in cer-tain cases. The primary limitation of the proposed method isits accuracy which is dependent on the voxel size. Also, theexecution time of the proposed algorithm varies as a cubicfunction of the grid resolution used for voxelization. Anotherissue that has not been addressed in this research is the inter-action between temporal and spatial coordinates for the caseof motion envelope (swept volume). As is evident from thecase study on probabilistic motion envelope (Sect. 4.1), theusability of the generated envelope is dependent upon theinteraction between the temporal and spatial coordinates.This aspect arises only when probability is super-imposedon top of the temporal and spatial data. These limitationsof the proposed method provide an opportunity for furtherresearch and development into envelope generation whichshall be undertaken in future work.

Acknowledgments This research was supported by General MotorsCompany. The views presented here do not necessarily reflect those ofour sponsor whose support is gratefully acknowledged.

References

1. Daniel, C., Kaufman, A.: Fundamentals of surface voxelization.Graph. Model. Image Process. 57(6), 453–461 (1995)

2. Tiwari, S., Fadel, G., Fenyes, P.: A fast and efficient compact pack-ing algorithm for free-form objects. In: Proceedings of the ASMEIDETC & CIE Conference (2008)

3. Tiwari, S., Fadel, G., Fenyes, P.: A fast and efficient compact pack-ing algorithm for SAE and ISO luggage packing problems. Trans.ASME J. Comput. Inf. Sci. Eng. 10(2), 021010 (2010)

4. Peternell, M., Pottmann, H., Steiner, T., Zhao, H.: Swept volumes.Comput. Aided Des. Appl. 2(5), 599–608 (2005)

5. Abdel Malek, K., Yang, J.: Swept volumes: foundation, perspec-tives, and applications. Int. J. Shape Model. 12(1), 87–127 (2006)

6. Blackmore, D., Leu, M.C.: Analysis of swept volume via lie groupsand differential equations. Int. J. Robot. Res. 11(6), 516–537 (1992)

123


7. Blackmore, D., Leu, M.C., Wang, L.P.: The sweep-envelope dif-ferential equation algorithm and its application to nc machiningverification. Comput. Aided Des. 29(9), 629–637 (1997)

8. Wirsching, H., Premkumar, S.: Statistical representations of humanpopulations in ergonomic design. In: Proceedings of the DigitalHuman Modeling for Design and Engineering Conference andExposition (2007)

9. Kim, Y., Vardhan, G., Lin, M., Manocha, D.: Fast swept volumeapproximation of complex polyhedral models. Comput. Aided Des.36(11), 1013–1027 (2004)

10. Liang, J., Edelsbrunner, H., Fu, P., Sudhakar, P.V., Subramaniam,S.: Analytical shape computation of macromolecules: moleculararea and volume through alpha shape. Proteins Struct. Funct. Bioin-form. 33(1), 1–17 (1998)

11. Ohtake, Y., Belyaev, A., Seidel, H.P.: An integrating approach tomeshing scattered point data. In: Proceedings of the ACM Sympo-sium on Solid and Physical Modeling, pp. 61–69 (2005)

12. Kazhdan, M., Bolitho, M., Hoppe, H.: Poisson surface reconstruc-tion. In: Proceedings of the Eurographics Symposium on GeometryProcessing (2006)

13. Lorenson, E., Harvey, E.: Marching cubes: a high resolution 3dsurface construction algorithm. Comput. Graph. 21(4), 163–169(1987)

14. Van Overveld, K., Wyvill, B.: Shrinkwrap: an efficient adaptivealgorithm for triangulating an iso-surface. Vis. Comput. 20(6),362–379 (2004)

15. Kobbelt, L.P., Botsch, M., Schwanecke, U., Seidel, H.P.: Fea-ture sensitive surface extraction from volume data. In: ACM SIG-GRAPH, pp. 57–66 (2001)

16. Moller, T.A.: Fast 3d triangle-box overlap testing. J. Graph. Tools6(1), 29–33 (2001)

17. Garland, M., Heckbert, P.S.: Surface simplification using quadricerror metrics. In: Proceedings of the ACM SIGGRAPH, pp. 209–216 (1997)

18. Hoppe, H.: New quadric metric for simplifying meshes withappearance attributes. In: Proceedings of the Conference on Visu-alization, pp. 59–66 (1999)

19. Kim, S., Lee, D., Yang, M.: Offset triangular mesh using the multi-ple normal vectors of a vertex. Comput. Aided Des. Appl. 1(1–4),285–291 (2004)

20. Ganesan, M., Fadel, G.: Hollowing rapid prototyping parts usingoffsetting techniques. In: Fifth International Conference on RapidPrototyping (1994)

21. Jung, W., Shin, H., Choi, B.K.: Self-intersection removal in trian-gular mesh offsetting. Comput. Aided Des. Appl. 1(1–4), 477–484(2004)

123

An envelope generation algorithm for packing and layout applications

Documents

Transcript of An envelope generation algorithm for packing and layout applications