Skip to main content

Review: 3D Printing with RepRap Cookbook (Packt)

Disclaimer: I received an offer from Packt Publishing to review the book “3D Printing with RepRap Cookbook”, written by Richard Salinas. Packt Publishing is a print-on-demand service, from which I already bought several books, ebooks and for whom I also authored my Unity for Architectural Visualization book and the Building an Architectural Walkthrough with Unity video course.

I received the eBook version free of charge, but the review is solely my own, personal opinion.




In contrast with my previous review on 3D Printing with SketchUp, this book is more independent of the software, but focuses on particular hardware. I don’t have such a machine within arms reach, but I do have access to a local Fab-lab where several CNC, lasercutting and 3D printing machines are available for visitors.

So what does this book offer?

It is a quite extensive book at 346 pages. The layout and quality is similar to other Packt books. If you are not familiar: the eBook has colored images, but the printed versions are black-and-white, which sometimes interferes with the legibility of screenshots.

Like most Packt books, this is not a scientific book, but a pragmatic book, written by experts rather than by professional writers.

In this case, the writing is practical, no-nonsense. The writer assumes that the reader has basic modelling skills and knows his or her way around finding the particularities online. There is not too much place spent in explaining trivial matter, which is fine for me.

For this book, the writer chose to focus mostly on freely available software and illustrates it on Windows 7, but most systems are available for other platforms too. You need access to a Reprap (or similar) printer and also software that interfaces with this machine. This is briefly explained in the preface.

Chapter 1 - Getting Started

The whole printing process is reviewed by scanning an object using a basic camera with the Autodesk 123D Catch software. This software will reconstruct a 3D model from the images. The model is than printed.

Scanning an object is an easy way to avoid the first pitfall most designers face: the 3D modelling process. While I am very versed with modelling in general, I understand the large amount of explanation that is required to get any model ready for printing before you can actually get started.

The writer advices to use a very simple object (a Lego-like brick, I believe from the Mega Bloks brand) and while this might be very different from what you would require in practice, it helps the process to be smooth. He also gives few handy tips on getting better results and avoiding possible problems. He also illustrates the manual stitching process, when 123D Catch does not find the right correlation between particular images.

Then the model is loading in the 3D Printing Utility from Autodesk (A3DP), which process the model into a printable STL file.

Finally, the 3D model in STL format is cut in 2D sections by a slicer software to generate the necessary instructions for a 3D printer, as G-code. The writer suggests two different slicer software systems: Slic3r and SkeInforge. This is where the size of the printing bed, the diameter of the filament wire and temperatures are set up. The final exported G-code file is what is sent to the 3D printer.

While the rest of the chapter is very detailed, with screenshots of the particular software, this is quite handy, as you need to check several numerical setting and in good Open-Source tradition, there are many of them, which can be very confusing for end users.

The final printed models were OK, but need further optimisation. This chapter gives you a head-start, but also numerous aspects to be improved, tweaked and corrected.


The chapter goes hands-on and explains every step along the way. This if fine for inexperienced readers, although I quickly start skipping parts - I’m getting less and less patient over the years, I guess.

Chapter 2 - Optimizing Print process

Here the scanned models from the previous chapter are revised, but in their form before they were optimised by the 3D Printing utility, using Autodesk Meshmixer software. In contrast with most Autodesk software, Meshmixer follows the Y=up convention from Maya and other 3D animation software, instead of Z=up from most CAD and BIM systems. Be warned.

Scaling and rotating is all possible, but I cannot help but think that I’d prefer the more precise control from a CAD system, such as Rhino or AutoCAD. And I also start to realise that the Pyramid shape used as example is actually a very trivial, basic form, which does not represent the real problems you’ll face in your own projects. That is always the dilemma with teaching material: good examples that illustrate an issue well are often not representative of actual project outcomes.

The writer also illustrates a few mesh-repairs, which illustrate modelling operations that might seem trivial for 3D sculptors (using ZBrush/Sculptris) but usually aren’t for architects and other designers.

Finally, we go back to the 3D printing process, but explaining how to generate “infill”: the support structure on the inside of a model, so it can be built without collapsing in the process. Here the writer shows the true value of this book: sharing practical advise: e.g. by explaining the main characteristics of the infill patterns and how they interfere with the printing process. He also illustrates possible errors when not using any infill, which is a valuable lesson and which could cause quite some trial-and-error otherwise.


Chapter 3 - Scanning and Printing with a Higher Resolution

This chapter focuses on different hardware and software.

It explains the DAVID Laserscanner, which uses a camera to capture the distortions of a projected regular pattern onto geometry. According to the writer, the photogrammetry process with 123D Catch works better for large objects (buildings, monuments), whereas the laserscanning process with DAVID seems to capture finer details.

Beware that the software for the DAVID Laserscanner is Windows-only. The chapter explains all the required steps in sufficient detail.

In addition, the Open Source and cross-platform Meshlab software is introduced here, to cleanup and assemble the scans (transferred using the Wavefront OBJ format). Of particular notice is the aligning and fusing of separate scans, to combine them into a single mesh.

Interestingly, this chapter also explains process of how to generate smoother models by tweaking the printer’s resolution. Suffice it to say that this chapter dives into detail that goes beyond introductory level, yet can be very hard to collect. So the writer does a good job of sharing his experience with the reader.


Chapter 4 - Modeling and printing with precision

New chapter, new software. I feel a trend coming. Here the writer switches to SketchUp Make, the free version of SketchUp, which is easy to use and free for non-commercial usage (beware of the license! You might be required to buy a Pro-version).

The writer choose the recreate the Lego-like brick in SketchUp and illustrates the usage of some extension scripts along the way. I personally feel the modelling description to not be really necessary, as an experience SketchUp user, but then again, I seldom do rounded edges in SketchUp.

Then there is a detailed section again on calibration, adjusting scaling and stretch and look at how a heated printing bed can avoid model warping.

Finally, all models so far are compared and (obviously) the model from SketchUp gives best result, as that is a precise recreation of the geometry, without artefacts that arise from scanning. So if the model is simple and straightforward, create it yourself. If it is organic, too complex or you need to capture something “as-is” scanning is the way to go.


Chapter 5 - Manipulating meshes and bridges

Again, new software is introduced. Here the writer looks at TopMod, an interesting (but deprecated) software to generate geometry based on algorithms and formulas. The writer looks at the surface subdivisions tools, which are also explored in MeshLab. He also explores an approach to generate “wireframe” models from a Mesh, using TopMod.

Then he looks at bridging (how to deal with gaps and spans) and also control of the speed and cooling process, even going as far as hacking some of the generated G-code to adjust the cooling and speed.


While this chapter might be too specific for most readers, it contains a treasure of knowledge.

Chapter 6 - Making the impossible

The chapter stays with TopMod and now looks at some alternative geometry generation methods from this software.

One of the models is unprintable as such (some parts would start somewhere in the middle of a void), so the writer describes how to use MeshMixer to create support structures.


PastedGraphic1-2014-08-5-12-44.png PastedGraphic2-2014-08-5-12-44.png

Chapter 7 - Texture - the good and the bad

Here, the writer intends the process of making physical, 3D textures on top of the geometry (not projected images, as we use in visualisation). Nevertheless, they are generated from image stencils and lead to particular care with modelling.


Another approach is patterning, where you can create protrusions through the geometry for some particular effect. The patterning approach on the mesh surface is more applicable into an architectural context, such as a Delauney Dual Edges pattern.

The second part of the chapter goes back into fine tweaking of printing parameters: travel speed, retraction, jitter and even randomising starting points of the printing. They are placed in this chapter as they can be used to avoid certain texture-like anomalies on the geometry, caused by the limitations of the printing process.

Chapter 8 - Troubleshooting issues in 3D modelling

There are quite some mesh problems that can occur and they are explained quite clear at the beginning of this chapter: self-intersecting faces, holes, non-manifold connections (e.g. two cubes sharing a single vertex), normals that point the wrong way.

First, the Repetier-Host software is used. While it does point to issues in the model, it is not the best system to make repairs. The writer then combines netfabb (the free Basic version), Microsoft Repair Service (powered by netfabb), Autodesk 3D Print Utility and Meshmixer. He also illustrates a manual correction using SketchUp, which is quite relevant for architectural users.

The chapter concludes with the creation of a hollow squid model, including a drain hole, to reduce printing costs (estimated using the Shapeways dashboard).


Chapter 9 - Troubleshooting issues in 3D printing

The final chapter looks at particular issues you can face with a RepRap printer. Again, quite detailed and quite specific. Can be vary valuable if you are the one doing the maintenance of the printer.


They cover the Firmware, G-code and Filament options.


This book is a good addition to the growing topic of 3D printing: it is extensive and gives valuable information. It is very detailed and as such requires a serious time investment for the reader. You might read it a first time to get an overview, but then you have to get hands-on with 3D printing. I feel that its primary value is on the depth that the writer reaches, assumably based on his experience with the process.

The choice of software systems is quite varied and might not appeal to all users. Somehow I find it a bit strange that the writer deliberately avoids commercial software. E.g. for Mesh repairs, the software from Materialise (Magics) is an industry-standard and while very expensive, it has been developed for correcting most problems with 3D models to print. Even a brief mention would be fine.

While too detailed for my taste, I can recommend this book if you have a RepRap or have access to one in a local Fab-Lab. But only if you are willing to spend the time going into detail and working hands-on with the tools, the software and the hardware.


Popular posts from this blog

Improve usage of BIM during early design phases

When I was collecting ideas for a book chapter on BIM (that seemed to never have emerged after that), I collected 10 ideas, which I believe still reflect good recommendations to improve the usage of BIM during the early design phases. These ideas are related to BIM software, but you can apply them in any flavor, as long as you can model with Building Elements, Spaces and have control over representation. Introduction This article gives an overview of several recommendations and tips, to better apply BIM applications and BIM methodologies, in the context of the early design phases. Many of these tips are applicable in any BIM application and they are based on experience gathered from teaching, researching and using BIM software. Sometimes they could help software developers to improve the workflow of their particular BIM implementation. Tip 1 : Gradually increase the amount of information In the early design phases, the architect makes assumptions and lays out the main design in

Getting BIM data into Unity (Part 9 - using IfcConvert)

This is part 9 of a series of posts about getting BIM data into Unity. In this post, we’ll discuss the IfcConvert utility from the IfcOpenShell Open Source IFC Library to preprocess an IFC model for integration with Unity. This is (finally?) again a coding post, with some scripts which are shared to build upon. Conversion of IFC into Unity-friendly formats The strategy with this approach is that you preprocess the IFC-file into more manageable formats for Unity integration. Most Web-platforms do some sort of pre-processing anyway, so what you see in your browsers is almost never an IFC-file, but an optimised Mesh-based geometric representation. However, it wouldn’t be BIM-related if we’d limit ourselves to the geometry, so we will parse the model information as well, albeit using another, pre-processed file. IFC to Wavefront OBJ I used a test IFC-model and used the IfcConvert-utility converted it into OBJ en XML formats. The default way to use it is very simple:

Getting BIM data into Unity (Part 8 - Strategies to tackle IFC)

This is part 8 of a series of posts about getting BIM data into Unity. In this post, we’ll discuss IFC as a transfer format towards Unity. As with the previous post, this is not a coding post, although hints and examples are provided. Open BIM and IFC Everybody who ever met me or heard me present on a conference or BIM-lecture will not be surprised to hear that I’m a strong believer in the Industry Foundation Classes (IFC), an open standard, with already two versions published as an ISO standard, being IFC2x2 and IFC4 (but surprisingly not IFC2x3 which is widely used). In the ideal world, this would be the format to use to transfer BIM data into another environment, such as Unity. So what are our options? Looking in the Unity Asset Store Assimp is a library which supports multiple formats, including IFC.   I did a few attempts, but alas without any success. It is possib