3D Printing Infill using Biomimetics Report

Christopher Murphy

ABSTRACT A study into generating a foam like structure to use as an infill pattern for 3D printing applications

2

Acknowledgments The author would like to thank Colin Burvill of the University of Melbourne and Martin Leary of RMIT, whose support allowed this project to take place. A special thanks to Rene Weller and Jorn Teuber, who allowed me access to the Protosphere algorithm and technical support. Additional thanks to Gabriel Zachmann and Stefan Guthe for there work on Protosphere. Without this program this project would have been much more difficult. An additional special thanks to Stephen Moore of the VLSCI for assisting with coding and conceptual ideas.

Table of Contents

1.   Executive Summary .................................................................................................................... 3  2.   Introduction ................................................................................................................................. 5  3.   Literature Review ....................................................................................................................... 5  3.1.   Bone Structure .......................................................................................................................... 5  3.2.   Engineering Foams .................................................................................................................. 5  3.3.   3D Printing ................................................................................................................................ 7  3.4.   3D Models ................................................................................................................................. 8  3.5.   Protosphere ............................................................................................................................... 9  3.6.   Mechanical Testing of 3D printed parts ................................................................................ 9  4.   Methodology .............................................................................................................................. 11  4.1.   Infill ......................................................................................................................................... 11  4.1.1.   Preparing 3D Geometry ..................................................................................................... 11  4.1.2.   Generating spheres ............................................................................................................. 11  4.1.3.   Preparing the final geometry ............................................................................................. 12  4.2.   Testing ..................................................................................................................................... 13  5.   Results ........................................................................................................................................ 14  6.   Discussion ................................................................................................................................... 15  6.1.   Infill Workflow ....................................................................................................................... 15  6.2.   Testing ..................................................................................................................................... 18  7.   Conclusions and Recommendations ........................................................................................ 20  Bibliography ..................................................................................................................................... 21  A.   Matlab code ............................................................................................................................... 22  B.   C++ Code ................................................................................................................................... 24  

3

1. Executive Summary 3D printing has taken off in popularity in the past few years, primarily thanks to the expiration of key patterns on Fused Deposition Modeling (FDM) has enabled the development of low cost (<2000USD) printers through open source hardware movements such as Rep-Rap. FDM involves heating a filament (mostly ABS or PLA plastic, but many other materials are available) to its glass transition temperature (close to melting) and extruding it through a small nozzle onto a platform. The nozzle and/or platform are capable of movement in all three directions (xyz-axis) and a 3D model is formed. This is achieved by breaking a 3D CAD (computer aided design) model into 2D slices and building up the model, layer by layer. The main advantage to this additive manufacturing approach versus traditional subtractive manufacturing (removing material from a bulk piece using CNC machines, lathes etc.) is that one, low cost machine can produce a near infinite variety of complex parts and assemblies. Another major advantage is the internal volume of a part no longer has to be solid material, the designer can choose any infill pattern they desire. This can lead to lighter, more efficient and more environmentally friendly parts as less material is required compared to solid parts and much less that traditional subtractive manufacturing (due to the fact that the material removed is waste product). Current methods for generating infill involve either masking a simple 2D pattern (such as cross-hatching) in each slice or generating 2D Hilbert curves (a space filling fractal) or similar space filling curves. While easy to implement there are two main drawbacks, firstly these 2D patterns do not exploit the 3D nature of the technology and secondly there appears to be no solid engineering basis to these patters. This project aims to address these two drawbacks while maintaining an easily implementation. This is achieved by turning to the field of biomimetic and using a naturally occurring foam structure like bone as the infill pattern. Foams have been used in the past and are of interest to the aerospace and automotive sector. Metallic foams have shown to retain the properties of the bulk material but have a much lower density (~75% of the foam is a empty space). Notably these foam structures can maintain close to the strength of the bulk material. Traditionally these materials are manufactured using advanced techniques such as a skeleton structure or injecting gas into a molten material. 3D printing can easily produce these structures with a great deal of accuracy. This is the focus of this project, however there is other research currently taking place. Other researchers have successfully used more advanced 3D printing technologies (laser sintering, where a high powered laser radiation source is used to melt a powdered material instead of extruding it) to produce micro-scaled (10-6m) lattice structures that exceed the strength of all currently known engineering materials at densities lower than water. This work brings some of these benefits to low cost printing, allowing more efficient parts to be produced. This is achieved by turning to sphere packing algorithms. These algorithms aim to fill a volume with spheres following a variety of specifications, such as packing the largest number of spheres in a volume or containing the largest volume possible within these spheres. This project utilises the Protosphere algorithm, it is a highly parallel algorithm that fills a volume with non-intersecting spheres with no real packing efficiency goals. It was developed for computer graphics applications but has two big advantages in this context. Firstly is its highly parallel nature means that the use GPGPU (General Purpose Graphical Processing Unit) computing, where the GPU (Graphics Processing Unit), which consists of 100s to 1000s of simple compute cores, are used to execute code in parallel (at the same time). Instead of placing one sphere at a time, thousands of spheres can be placed at the same time. This allows low cost PCs or laptops capable of GPGPU code execution to rapidly generate an infill pattern. The second advantage is that the spheres generated

4

are non-intersecting, thus the geometry produced is physically plausible. There is no need to deal with spheres where spheres share volume and these areas would have to be detected and resolved into geometry that the printer can process. The process of filling the object involves passing a slightly smaller 3D model than the end object desired, the main feature is that the surface of the smaller model maintains a constant distance from the final model. This forces a solid outer shell on the object as currently with 3D printing software each surface is assigned a thickness and when these surfaces intersect this can lead to holes or other undesired geometry. This smaller model can either be created manually by the user or by processing the 3D model. The processing involves calculating the normal of each vertex in the model and moving the vertex along that normal to produce the desired outcome of a smaller volume. This geometry is then passed to the Protosphere algorithm, which produces the xyz coordinate of the spheres and radii of the spheres (the program is capable of controlling the number and size of spheres). Using Matlab, the radii of each sphere is reduced slightly and the data converted to 3D geometry (formatted as a Wavefront .obj file type). This geometry is then merged with the original geometry and exported as an .stl (stereo lithography) file type, which can be printed using current 3D printing software. The 3D printing software interprets the geometry as follows, any volume inside the object but not contained by a sphere is subject to being filled with material and using settings in the software this volume can either be solid material or further optimised using the software’s 2D infill patterns. This process mimics the foam like structure of bone, which based off previous works in foam, should produce stronger and lighter 3D printer object compared to traditional methods. It is an easy, simple and versatile workflow (only requiring a manifold/airtight surface, a requirement of 3D printing as well) that while developed with low cost FDM in mind, is independent of FDM technology and could be produced on any 3D printing technology. The production of strong parts that require less material further strengthens the environmental benefits of 3D printing technology.

5

2. Introduction Currently with entry level 3D printing (consumer ABS/PLA printers <$5000AUD) the infill pattern generated are generally simple patterns derived from path finding algorithms, Hilbert curves and repeatable geometry. All these patterns are generated on the 2D slices of an object to be printed, they do not exploit the 3D nature of printing to use 3D infill patterns. By moving to a 3D pattern, it should be possible to achieve a more sophisticated infill pattern that delivers more strength for the same amount of material compared to traditional methods. By mimicking bone structure to produce closed cell foam like structure the hope is that this objective will be achieved and validated thru crush testing of samples. 3. Literature Review

3.1. Bone Structure Bones form the endoskeletons in a large variety of animals and humans. It provides the structure for the being as well as other functions, such as producing blood cells. It primary consists of a composite of calcium phosphate and collegen. The structure of the bone has two main phases, a dense, tightly packed cortical bone and trabecular bone; a soft, open cell foam type structure. The cortical bone is a stiff material where the trabecular bone is more soft and flexible [1].

Figure 1: Internal structure of human bone [1]

The main point is to note the foam like structure of bone. Using the idea of biomimetics this structure will be mimicked with the idea that if it worked for nature, it should work well in this context.

3.2. Engineering Foams The concept of foam structures in engineering materials is not a new one, with texts existing on the subject (such as the one by Ashby referenced in this report). The main point of interest (in the context of this report) is their low density and high strength (relative to other materials), there are other notable properties that make foams attractive but are of little concern here [2]. While the field is still young, it is maturing, as there is interest in using foams in applications, from the perspective of a its strength-density properties, in automotive and aerospace applications [2].

Figure 2 Strength-Density Ashby diagrams. On the left is an overview of all engineering materials [3] and the

right [2] is the foam region, with many commercial types of foam shown.

Figure 3 Panel from a concept car produced by Karmann Gbmh utilising aluminium foams in the panels [2].

The structures of foams have two classifications, open cell and closed cell. Closed cell foams feature discrete, non-connected pockets (pores) in the medium where in open cell foams these pores are connected [2].

Figure 4 A X-Ray tomograph of an Alulight foam, a closed cell aluminium foam [2].

7

Metallic foams have been a point of interest in the automotive and aerospace for these and other properties [2] [4], as can be seen in Figure 3.

3.3. 3D Printing 3D Printing, namely fused deposition modelling (FDM), is a manufacturing process where material is added to produce the object to be built [5]. This is opposite to traditional methods such as CNC (computer numerically controlled) machining that uses subtractive manufacturing (removing material from a bulk piece to produce the final part). The advantage is that complex objects can be produced with little effort (there is no need for multiple machining steps typically required in subtractive manufacturing) and without the need for expensive die (as would be required for plastic injection moulding). FDM was originally conceived in the 1980s, with S. Scott Crump attributed as its creator [6]. The technology remained expensive until the expiration of patterns on the technology allowed open sourced communities to develop low cost printers, most notably the Reprap community formed by Dr Adrian Bowyer of the University of Bath [7].

Figure 5: General layout of a 3D printed object, it is sliced into layers that are built on each other. [5]

The low cost FDM 3D printers typically use a plastic (ABS or PLA) filament that is forced through a nozzle that is heated to the glass transition temperature of the filament [8]. The nozzle is moved through space and the extruded plastic forms the object, which is formed layer by layer. This is done by taking 3D CAD models slicing them into 2D layers along the z-axis and using these slices to generate gcode to control the movement of the nozzle. As these models are interpreted as shells, the volume inside is filled with either solid material or a generated pattern. Currently this infill pattern is applied to the 2D slice and can be some simple geometry or a pattern generated by some geometric algorithm (such as a Hilbert curve) [9]. This infill provides the majority of the structural support for a part. While simple to compute, this approach does have disadvantages. Most notably the infill isn’t homogenous in all directions, combined with the fact that the layers can delaminate and separate can make printing objects where mechanical properties are important difficult. Laser sintering technology, which uses the same concept of additive manufacturing, but instead of extruding material onto the build surface it lays a powered material over the entire build are and then a laser either melts or sinters the material to form the solid part [10]. There are high gains in accuracy over FDM due to the physics of optics and the layer effect is less pronounce. Recently 3D laser lithography has been used to produce a structured approach to generating a bone like structure that maintained a compressive strength close to the solid material (aluminium/polymer composite) but with a drastically lower density [11].

8

Figure 6: A Hilbert curve infill pattern. The black lines indicate the current layer and the pink lines indicate the

previous layer. [9]

3.4. 3D Models The method of storing 3D geometry data is based on the same underlying principals, a focus on the Wavefront object (.obj) file format will follow, given its usage in this project. The .obj file format was developed by Wavefront Technologies (through various mergers now apart of Autodesk) and has its origins in computer graphics, thus many features it has will not be exploited and only the basics used. 3D geometry consists of three building blocks, vertices, edges and faces. A vertex is a point in space, described by its xyz coordinate. An edge is the line formed between vertices and a face is the area enclosed by a series of edges. Using these three building blocks geometric data can be stored [12].

Figure 7 The basic building blocks of 3D geometry [12]

In the .obj file format the vertex data is stored as

v x y z The ‘v’ indicates the line contains vertex data and is followed by the xyz location of the vertex. Each vertex is identified by a number assigned to it in the order it appears in the file, the first vertex is 1, the second is 2 and so on. The next step is to define the faces.

f v1 v2 v3 … vn The ‘f’ indicates the line is defining a face and the numbers following list the vertices that form the face (using the identifying number assigned above). The face must consist of at least three vertices. The order in which the vertices are listed is important too. For example v1 to v2 defines an edge.

9

Thus the face is defined by listing the vertices encountered as the perimeter of the face is transverse in either a clockwise or counter clockwise direction. While the .obj has the ability to manually define the normal of the face, if it is not specified it is assumed to be a vector that is perpendicular to the surface and its direction follows the ‘right hand rule’ [13].

3.5. Protosphere To achieve the desired pattern a sphere-packing algorithm will be used. This will provide a good approximation to the desired foam structure. Another benefit of this approach is that the algorithm can fill any volume with the computational power found in modern desktop/laptop computers. Specifically the Protosphere algorithm, a GPU (Graphics Processing Unit) accelerated sphere-packing program. It makes use of the Nvidia CUDA framework, which is designed to allow programmers to use an Nvidia GPU for GPGPU (General Purpose computing on Graphic Processing Unit) applications [14] [15]. To make the most of GPGPU computing the idea is to make an algorithm highly parallel, as GPUs consist of many cores. For example, Nvidia GPUs are build from SMX (streaming multiprocessor) units, each of these modular units consist of 192 CUDA cores [16]. Protosphere produces a feasible sphere packing of an object; that is none of the spheres overlap. The only condition on the object to be filled is that it must be possible to measure the distance to the surface of the object from any point inside the object. The general flow of the algorithm is to place a prototype randomly inside the object, the shortest distance to the surface is calculated and the prototype is pushed away from the surface by that measured distance. This is repeated until the prototype converges to a location, it is then expanded into a sphere and the process is repeated until the desired number of spheres is reached. For the parallel version the object is divided into a grid and the prototypes are placed within and contained in the grid cells [14] [15]. This allows a fill pattern to be generated rapidly.

Figure 8: General flow of the Protosphere algorithm, showing the movement of the prototype as it converges to a

final location [15].

3.6. Mechanical Testing of 3D printed parts Testing of materials to determine their mechanical properties is a well defined area, with standards to ensure results are comparable to others as well as valid data. These provide suitable starting points for developing tests but FDM introduces additional variables that complicate the assessment

10

of the mechanical properties of printed parts. Rigorous tensile testing has been preformed on parts produced by low cost FDM printers by Tymrac and found that the orientation of the layers had a notable impact on the spread of tensile strength of the parts [17]. Other work, using laser sintering technology exploring the same properties came to the same conclusions [18]. This is expected as visual inspection of parts reveal an inhomogeneous surface. Both works revealed that the process of 3D printing did not effect the ability of the material to reach its theoretical maximum (compared to test samples produced using traditional methods) provided they were produced at the correct orientation. Given that the field of 3D printing is still young as the technology is only just becoming readily available, there is a lack of standards or other studies to follow, and more rigorous testing must be preformed to fully understand and quantify the results, this could involve testing hundreds of samples [17] [18].

4. Methodology 4.1. Infill

4.1.1. Preparing 3D Geometry The main criterion for the 3D model to be printed with the infill pattern is identical to current requirements for 3D printing. The main point is the model has a manifold surface; that is the surface fully encloses a volume with no holes (each face on the model is surrounded by neighbours). The internal volume is well defined. Early testing (discussed in more depth in the discussion section) revealed an additional, recommended step of forcing an outer shell on the object by using a slightly smaller 3D model in the sphere-filling step. The distance between the surface of the smaller model to the larger, original model should be constant. The distance is the desired thickness of the shell. This can was achieved in two ways. Firstly the smaller object can be manually produced, this is easy for simple geometry or geometry generated in CAD programs. The second method explored is suited to dealing with more complex geometries (such as models produced with 3D scanning or more organic surfaces). The basic idea is to move each vertex of the model a fixed distance along its normal vector. The calculation of the normal vector is a common problem and predefined functions can be used. In this case a small program using the VTK (Visualisation Tool Kit), an open source toolkit for handling computer graphics and visualisation was used. The normal for the vertex is calculated by taking the average of the normal of the surrounding faces. A perfect result is not essential (as this smaller model is a dummy for the sphere-filling stage only and is disregarded after that step), but care must be taken around thin features, as vertices may pass each other and distort or destroy the surface. Currently there is no check for this in the software and the shrunken model must be verified manually.

Figure 9 The shrunken geometry produced by the second method, the outer dots are the vertices of the original

model. The original model is the Stanford bunny.

4.1.2. Generating spheres Given the maturity of the Protosphere program, this is a simple step. The geometry to be filled is imported into the program and the sphere packing preformed. Once a pattern has been generated the xyz coordinate of the centroid and the radius of each sphere is exported to a text file for processing in the next step. The logic and thought process for this step will be discussed from a general standpoint.

12

There are many ways to approach the sphere-packing problem but for this workflow the key feature is that the sphere produced do not intersect, as well defined geometry that is suitable for printing is essential. Provided there are no intersecting spheres then no additional steps to ensure the geometry produced is suitable (are the surfaces manifold etc.) are required. Another essential feature of the program is to control the range of radii possible of the spheres produced. Spheres that are too small; smaller than the resolution of the printer are to be avoided as they will not be printed (the volume will be solid plastic). Large spheres are also to be avoided, as at some point the internal volume would be a hollow void and leave the scope of this work. Any sphere packing algorithm can be used for this provided it meets this criteria. Protosphere’s main advantage is its parallel nature, which allows volumes to be filled rapidly.

4.1.3. Preparing the final geometry The next step is to turn the output from Protosphere into usable geometry and merge it with the model to be printed. A simple Matlab script is used to achieve this. Using the meshgrid function a surface is generated and then mapped to a spherical shape. This is done for each sphere. As this is a common task, there are many solutions that can be used. The next step produces an .obj file from this data. The vertices are extracted from the mesh produced. As each vertex is written it is moved to the correct xyz location required. The key point in this step is defining the normal of each face to point inwards for each sphere. The printer software interprets the side of the face that is in the direction of the normal to be the outer surface. Thus by pointing the normal of each face of each sphere to point inwards the software interprets the volume contained by the spheres to be a void and any volume inside the model but not contained by a sphere to be subject to the printers standard infill pattern. The method for writing to .obj files uses lightly modified code produced by Anders Sandberg [19]. Also, the radius of each sphere is reduced to ensure no sphere is in contact with another or the outer surface (while the spheres are non-intersecting, they are allowed to be in contact). This is another variable that can be altered. The next step is to merge this data with the model to be printed. This is done using the meshlab program. The model to be printed and the spheres geometry file are opened in the one workspace and the filter ‘Flatten visible layers’ is used to unify the two geometries into one. Then the geometry is exported to an .stl file format and then printed using standard 3D printer software.

Figure 10 A simplified version of the final geometry produced. The blue lines indicate the normal vector of each

face.

13

4.2. Testing Compression test samples were prepared by following (roughly) set out by Ashby [2], cylindrical samples with a diameter to height ratio of 1.6 and setting the maximum radii such that at least eight spheres can fit across the sample, slightly larger than the recommended ratio of 1.5 and seven unit cells across. This should make the results independent of size. It is worth noting that these guidelines were developed in line with metallic foams, not polymer foams. The samples were crushed to a strain of about 0.8. The cylindrical samples have a diameter of 20mm and a height of 32mm. The forced shell thickness was 0.2mm. The radii of the spheres generated ranged between 1mm and 0.5mm. All samples were made from PLA and produced on a Flashforge Creator Pro. Six samples were tested for the purpose of obtaining preliminary data.

Sample Volume (of material) (mm3) Mass (g) 1A 8024 10.4 1B 8024 10.4 2A 8545 11.1 2B 7986 10.3 2C 8317 10.8 2D 7787 10.1

Solid Cylinder 10053 13.0 Table 1 Summary of test samples

5. Results

Figure 11 Stress strain graph of the compression test

Figure 12 The linear region of the stress strain graph before failure occurs

6. Discussion

6.1. Infill Workflow The workflow itself proved to be simple and effective. The most complex element is the sphere-packing algorithm, which is generally well understood (for the purposes of developing infill patterns) from a mathematics and programming point. Converting the workflow into a self-contained program should present no real obstacle to a fluent programmer. One problem that arose during printing was that the time to slice the file was extremely long. The Stanford bunny sample used as a test piece could take hours to slice. The printing software lacks any timing statistics for slicing and any real insight to the performance at each stage. The source of the issue is most likely the print head path generation code not being optimised for the complexity of each slice, as it is still trying to apply its infill algorithms to any area not contained by a circle (looking at a 2D slice). Modifying an open-source printing program such as slic3r to reveal more information into the slicing process could reveal where the algorithms are failing to deal with geometry. This information could help the development of this workflow into an infill procedure that can be integrated into printing software, as this slowdown would have to be addressed before it could be effective.

Figure 13 The Stanford bunny ‘stress test’ sample produced and its internal structure. Note the open cell

structure on the surface and around the small spheres on the green section. Early testing revealed an interesting side effect that could be leveraged. When printed using the PP3DP Up software (circa 2014, effect evident in multiple revisions of the software) when the sphere radii has not been reduced (spheres are in contact with others) a more open cell foam like structure is observed. It appears that when each surface is assigned a thickness (as in the model, the surface is infinitely thin) so the filament can trace the path, surfaces intersect and the software reacts to this by ignoring the intersecting surfaces. This effect is illustrated in the pictures of the white ABS and red PLA Stanford bunny (Figure 13 & Figure 15). While considered, an open cell structure approach was not implemented into the workflow as some approach to re-mesh and validate the mesh after intersecting the spheres would have to be developed (effort was focused on the closed cell structure). Further work could harness the effect evident in the software to generate the open cell structure with ease, however with the increasingly closed source nature of 3D printing

16

it is most likely that this effect would have to be emulated in new code versus leveraging the existing code that produces this effect.

Figure 14 A selection of test prints produced during development of the workflow. All are ABS prints.

There is also no reason why the infill pattern is restricted to spheres only. Any branch of geometry designed to fill a 3D space could be utilised. An alternate approach considered in this project early on was to leverage meshing algorithms found in FEA (Finite Element Analysis) packages, the edges of the generated mesh would have been assigned a thickness (and the resulting 3D geometry) and the mesh healed at each vertex. Other 3D shapes could be explored as well as 3D fractals, to name a few. Following the general logic of this workflow any process designed to fill some volume indiscriminately can be leveraged; the challenge is testing and quantifying the benefits.

Figure 15 A smaller PLA version of the Stanford bunny, no issues were observed when scaling down the size.

Moving forward, this work could be expanded into a process for generating an automated workflow to produce optimised infill pattern. For example, some simple FEA (either assumed loading or allow the user to select expected loading using a point-and-click style simple interface) could be preformed on different infill patterns and print orientation optimisation work done by RMIT [5] could be preformed on the structure to ensure that the resulting infill is structurally sound during manufacture (no support material required). This would be plausible due to the rapidly increasing compute power of low cost embedded platforms (the processors powering phones, tablets, TVs, smart wearables), namely GPU processors. For example the Nvidia Tegra K1 platform [20]

17

features the same desktop class GPU used to calculate the sphere packing in this project. This could be integrated into the 3D printers themselves and complex infill patterns could be generated regardless of the end users PC hardware.

Figure 16 The Stanford bunny, filled with spheres. This is the geometry used to generate the test print seen in

this report. It contains roughly 8000 spheres.

One drawback encountered the rather hit and miss results with the support structure generators (scaffolding generated to support overhanging features). Depending on the size of the spheres, the program may decide to place support structure inside the spheres (Figure 17). Currently the only solution is to turn off support structure generation. If this process were integrated into a software package it would be a non-issue. If support structure were required, it would have to be manually created in the original geometry.

Figure 17 A test print where support structure has been generated inside the spheres. An undesirable effect.

A final noteworthy point is that this approach generates a more homogenous infill pattern than current approaches. This removes the infill orientation as a variable the designer has to consider

18

when choosing the print setup and they can focus no choosing the orientation that is most favourable from a layer perspective. Also note that all samples produced in development of the workflow were produced on an UP printer produced by PP3DP.

6.2. Testing Cylindrical test samples were not the first consideration, the original solution was to use box samples, however regular issues with layer delamination caused this idea to be abandoned (Figure 18). Box and cylindrical test samples with supporting scaffolds were produced but proved to be unnecessary and the small cylindrical samples used did not suffer from this issue. However, the issue of layer delamination and the effect on the quality of prints produced using this method could be explored, as the source of this error was not clear. One of the test samples used for testing was opened to verify that the internal structure produced was valid (Figure 19). The mass reduction achieved with the test samples (compared to a bulk sample) ranged from 77.4-84.9% of the mass of a solid sample. While this is not as drastic as mass reductions in other foams (~10% of the bulk material [2]), the size of the sample and the resolution of the printers restrict the possible gains. Due to the issues encountered while trying to produce larger samples, lower densities were not explored but this can be done in future, more in depth testing. The testing revealed that the infill pattern produced no notable degradation in quality (versus bulk material). All samples preformed with equal performance, with linear compression behaviour ending at roughly at 25-35MPa and a stain of 0.04, after which failure starts to occur. At a strain of 0.6 and stress of 80MPa (roughly) it appears full failure of the structure has occurred. Looking at the linear region a compressive Young’s modulus of 768-1020MPa is seen, however this is from loading, and not read off the unloading curve so it should be considered a ballpark figure.

Figure 18 A failed box sample produced, note that partial layer delamination is evident in three layers. Two

near the bottom and one at the top.

19

Figure 19 Internal structure of the compression test sample.

While compressive strength data for PLA seems to be rare, some studies into blends contain control samples with similar results obtained here [21]. There is enough evidence to suggest that further investigation into this infill pattern is warranted, but to fully quantify the variables a large amount of testing must take place. It would also be of worth using other additive manufacturing technologies and exploring their response to this infill, as the workflow is not tied to any particular technology.

7. Conclusions and Recommendations Overall, this project was a success, the end goal was a proof of concept and this was achieved. A workflow to develop an infill pattern that has foam like structure was developed. The process, which leveraged pre existing sphere packing algorithms proved to be quite simple and robust. The usage of the Protosphere algorithm allowed the patterns to be generated rapidly, which would make the concept suitable for integration into end user printing software. While minor issues were encountered, these would be easily solved during the development process. The base logic could be used to test other space filling algorithms and their suitability for generating infill patterns. Indeed a simple solution is (at most times) is the best and most elegant solution. Another positive is that the process is not restricted to low end FDM printers (the original target) as at no point did the technology of the printers come into the generation of the pattern, it was a purely geometrical exercise. Thus the work could be tested and deployed on other AM machines. Testing proved to be more of a mixed bag; the preliminary results support the concept of the infill pattern and justify further work on the infill pattern. The issue is due to the fields of 3D printing and foam structures (for engineering purposes) still being quite young, standards for testing have not been developed as the variables and their impacts are still being understood. To fully quantify the properties a huge battery of tests (involving hundreds of samples) would have to be preformed and analysed. This is in contrast to traditional materials testing where good results can be obtained even in an undergraduate laboratory exercise due to the maturity of the field. This area has huge scope for additional work, especially as industry becomes more interested in the fields of engineering foams and 3D printing for use in manufacturing. Summarising future work that could be undertaken

• Development of the workflow into a software package • Exploration of other methods for infill, such as meshing algorithms and other fractal

patterns • Materials testing to fully understand the variables that impact the mechanical properties of

3D printed parts

21

Bibliography

[1] National Cancer Institute. Structure of Bone Tissue. [Online]. http://training.seer.cancer.gov/anatomy/skeletal/tissue.html

[2] A.G. Evans, N.A. Fleck, L.J. Gibson, J.W. Hutchinson and H.N.G. Wadley M.F. Ashby, Metal Foams: A Design Guide, 1st ed. Burlington, USA: Butterworth-Heinemann , 2000.

[3] Michael F. Ashby, Materials Selection in Mechanical Design, 3rd ed. Burlington, Massachusetts, USA: Butterworth-Heinemann, 2005.

[4] Christian Augustin Andreas Öchsner, Multifunctional Metallic Hollow Sphere Structures Manufacturing, Properties and Application, 1st ed. Berlin, Germany: Springer-Verlag , 2009.

[5] Mohammad Babaee, Milan Brandt, Aleksandar Subic Martin Leary, "Feasible Build Orientations for Self-Supporting Fused Deposition Manufacture: A Novel Approach To Space-Filling Tesselated Geometries ," Advanced Materials Research , vol. 633, pp. 148-168, 2013.

[6] 3ders. (2014) 3D Printing History. [Online]. http://www.3ders.org/3d-printing/3d-printing-history.html

[7] Reprap wiki. (2014) Reprap: About. [Online]. http://reprap.org/wiki/RepRapWiki:About [8] Makerbot, Makerbot Replicator 2 User Manual.: Makerbot, 2014. [9] Slic3r. (2014) Slic3r Manual: Infill Patterns and Density. [Online].

http://manual.slic3r.org/InfillPatternsAndDensity.html [10] University of Texas. (2013, May) Selective Laser Sintering, Birth of an Industry. [Online].

http://www.me.utexas.edu/news/2012/0712_sls_history.php#ch4 [11] 1, Stefan Hengsbachb, Iwiza Tesaria, Ruth Schwaigera, and Oliver Krafta Jens Bauera, "High-

strength cellular ceramic composites with 3D microarchitecture ," Proceedings of the National Academy of Sciences, vol. 111, no. 7, pp. 2453–2458 , Feburary 2014.

[12] 3D Shapes Org. (2014) 3D Shapes Worksheets. [Online]. http://3dshapes.org/faces-edges-a-vertices-explained-for-3d-shapes.html

[13] Wavefront Technologies. Object file specifications. [Online]. http://www.martinreddy.net/gfx/3d/OBJ.spec

[14] René Weller, Gabriel Zachmann, Stefan Guthe Jörn Teuber, "Fast Sphere Packings with Adaptive Grids on the GPU," GI-VRAR, 2013.

[15] René Weller, "New Geometric Data Structures for Collision Detection," Dissertation 2012. [16] Nvidia, "NVIDIA GeForce GTX 680," Nvidia, Whitepaper 2012. [17] M. Kreiger, J.M. Pearce B.M. Tymrak, "Mechanical properties of components fabricated with

open-source 3-D printers under realistic environmental conditions," Materials and Design, vol. 58, pp. 242-246, Febuary 2014.

[18] Tomislav, Pero Raos, and Marija Somolanji Galeta, "Impact of structure and building orientation on strentgh of 3D printed models ," KGK Kautschuk Gummi Kunststoffe, vol. 65, no. 10, pp. 36-42, 2012.

[19] Anders Sandberg. (2002, Mar.) Anders Main Page. [Online]. http://www.aleph.se/Nada/Ray/matlabobj.html

[20] Nvidia. (2014) Nvidia. [Online]. http://www.nvidia.com/object/tegra-k1-processor.html [21] Masaki OMIYA, Takenobu SAKAI, Philippe VIOT Toshitaka YAMAMURA,

"EVALUATION OF COMPRESSIVE PROPERTIES OF PLA/PBAT POLYMER BLENDS ," in Asian Pacific Conference for Materials and Mechanics, Yokohama, 2009, pp. 13-16.

22

A. Matlab code

clc close all clear all for cnt=1:7 fprintf('Reading file number %03d... ',cnt); file = sprintf('%03d.spheres',cnt); sphere1 = dlmread(file, ' '); %sphere = [0 0 0 0.5;0 1 0 0.5;1 0 0 0.5;1 1 0 0.5;0 0 1 0.5;0 1 1 0.5;1 0 1 0.5;1 1 1 0.5]; fprintf('Done\n\r'); reverseStr = ''; %status update worker redu = 0.2; phi=linspace(0,pi,7); theta=linspace(0,2*pi,14); [phi,theta]=meshgrid(phi,theta); noOfSpheres = length(sphere1); for a=1:noOfSpheres x{a}=(sphere1(a,4)-sphere1(a,4)*redu)*sin(phi).*cos(theta); y{a}=(sphere1(a,4)-sphere1(a,4)*redu)*sin(phi).*sin(theta); z{a}=(sphere1(a,4)-sphere1(a,4)*redu)*cos(phi); pct = (a/noOfSpheres)*100; msg = sprintf('Generating Spheres: %3.2f pc', pct); %status fprintf([reverseStr, msg]); %reverse deletes previous update, then prints. No newline char so all stays on one line reverseStr = repmat(sprintf('\b'), 1, length(msg)); end sprintf([reverseStr,'Generating Spheres: Done ']); sprintf('\n\r'); fileWrite = sprintf('%03d.obj',cnt); fid=fopen(fileWrite,'w'); count = 0; normals=0;

nn=count+1; for d=1:noOfSpheres l=size(x{d},1); h=size(x{d},2); n=zeros(l,h); fprintf(fid, 'o Sphere.%d\n',d); for i=1:l for j=1:h n(i,j)=nn; fprintf(fid, 'v %f %f %f\n',x{d}(i,j)+sphere1(d,1),y{d}(i,j)+sphere1(d,2),z{d}(i,j)+sphere1(d,3)); fprintf(fid, 'vt %f %f\n',(i-1)/(l-1),(j-1)/(h-1)); if (normals) fprintf(fid, 'vn %f %f %f\n', nx(i,j),ny(i,j),nz(i,j)); end nn=nn+1; end end fprintf(fid,'g mesh\n'); %l=size(x{d},1); h=size(x{d},2); for i=1:(l-1) for j=1:(h-1) if (normals) fprintf(fid,'f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d\n',n(i,j),n(i,j),n(i,j),n(i+1,j),n(i+1,j),n(i+1,j),n(i+1,j+1),n(i+1,j+1),n(i+1,j+1),n(i,j+1),n(i,j+1),n(i,j+1)); else fprintf(fid,'f %d/%d %d/%d %d/%d %d/%d\n',n(i,j),n(i,j),n(i+1,j),n(i+1,j),n(i+1,j+1),n(i+1,j+1),n(i,j+1),n(i,j+1)); end end end pct = (d/noOfSpheres)*100; msg = sprintf('Writing Spheres: %3.2f pc', pct); %status fprintf([reverseStr, msg]); %reverse deletes previous update, then prints. No newline char so all stays on one line reverseStr = repmat(sprintf('\b'), 1, length(msg)); end fprintf([reverseStr,'Writing Spheres: Done ']); fprintf('\n\r'); fprintf(fid,'g\n\n'); fclose('all'); end fprintf('Finished\n');

24

B. C++ Code

#include "vtkOBJReader.h" #include "vtkPolyData.h" #include "vtkPolyDataNormals.h" #include "vtkPointData.h" #include "vtkFloatArray.h" #include "vtkDataArray.h" #include "vtkSTLWriter.h" #include "vtkPolyDataWriter.h" #include "vtkSmartPointer.h" #include "vtkSystemIncludes.h" #include <iostream> int main(int argc, const char * argv[]) { double point1[3]; double normal[3]; double alpha = 0.05; vtkOBJReader* OBJReader = vtkOBJReader::New(); OBJReader->SetFileName("bunny.obj");//argv[1]); OBJReader->Update(); vtkPolyData* surface = OBJReader->GetOutput(); vtkPoints* points = surface->GetPoints(); vtkPolyDataNormals* PolyDataNormals = vtkPolyDataNormals::New(); PolyDataNormals->SetInputData(surface); PolyDataNormals->Update(); vtkFloatArray* normals = vtkFloatArray::SafeDownCast(PolyDataNormals->GetOutput()->GetPointData()->GetNormals());

25

for(int p=0; p<points->GetNumberOfPoints(); p++) { points->GetPoint(p, point1); normal[0] = normals->GetComponent(p,0); normal[1] = normals->GetComponent(p,1); normal[2] = normals->GetComponent(p,2); point1[0] -= normal[0]*alpha; point1[1] -= normal[1]*alpha; point1[2] -= normal[2]*alpha; points->SetPoint(p, point1); } vtkSmartPointer<vtkSTLWriter> STLWriter = vtkSmartPointer<vtkSTLWriter>::New(); STLWriter->SetFileName("Output.stl"); STLWriter->SetInputConnection(OBJReader->GetOutputPort()); OBJReader->Update(); STLWriter->Write(); STLWriter->Update(); std::cout << "Done\n"; return 0; }