[icesl] Things to do with IceSL: Arcade bartop!

After an exciting but somewhat stressful SIGGRAPH deadline I allowed myself a little fun and decided to use IceSL to model and laser cut (and 3D print) a complete Arcade bartop :-)

Here is the design in IceSL:

 

Of course it is fully parametric! It can easily be adapted to screens of different sizes, other joysticks and buttons. The bartop is quite small, I wanted something that would nicely fit on a table and not look bulky.

Here is a transparent 3D view and an exploded view in IceSL:

 

And the final result! 

 

All parts are laser cut using G-code produced by IceSL, using the 'laser' profile (gcode is sent to a smoothieboard driven CO2 laser cutter). This is using 3 mm plywood. 

The insides of the 'beast':

This is of course powered by a Raspberry Pi 2, running RetroPie. I went for Sanwa hardware ; no regrets, the buttons and joystick are indeed super nice. I use a small USB pad emulator board to plug the joystick and buttons -- but it seems GPIO pins could be used as well. The screen is a HDMI TFT panel, size 10.1 (ref LP101WH1), which has a reasonable resolution of 1366x768 -- but there are many other models out there, I picked this one based on price/availability. For the sound I took apart a pair of Logitech Z130 speakers (50mm diameter, fits nicely).

I learned quite a few lessons building this. The 3D preview in IceSL has been incredibly useful, as well as the ability to interactively move things around. I used 3D models of all electronics so that I could check for a proper layout and avoid collisions between the different parts. Nevertheless, I got a few things wrong mostly because I did not model the plugs (USB, HDMI, power) and these take *a lot* of space. This is the second prototype I made, the first one had a few issues and required some manual work to adjust. This one was taken right out of the cutter bed and assembled without requiring any drilling or gluing (everything tightly fits together).

I model all planks in their cutting position (thickness along Z), and define for each a transform to place it in the final 3D model. For instance the pad board is named 'pad_board' and its transform is 'pad_board_T' (just a matrix). To cut the board I use 'emit( pad_board )', whereas to display it in the final model I used 'emit( pad_board_T * pad_board )'. 

To create the finger joints I model only one side on one board and then use the following trick, e.g. between the left side board and the floor board:

side_L_board = difference( side_L_board , inverse(side_L_board_T) * floor_board_T * floor_board )

If you are not familiar with 3D matrices and transforms this may be a bit tricky to understand. 'side_L_board_T' is the transform (matrix) that puts the side board in position in the final model. Thus, inverse(side_L_board_T) is the matrix that moves everything back to the side board cutting space ; as if the entire final model was rotated to lie on the left side. Thus, writing 'inverse(side_L_board_T) * floor_board_T * floor_board' means that the floor board is first placed in the final model (by matrix floor_board_T) and then rotated back to the side (by matrix inverse(side_L_board_T) ). This is when I subtract the floor board from the side board. This effectively carves the connectors (from the floor board) out of the side board. By following this method you can easily model all connectors while being sure they will match. Another example of the power of CSG :-)

I still have a few things to add to finalize the bartop: external USB/Ethernet plugs, and most importantly an independent power supply (it requires three power plugs!) and of course paint and stickers. But for now, let's play some retro-games!

[3dprint] 3d infilling: faster, stronger, simpler

Sparsity: 80% empty (compared to volume of full cube)
Strenght: I applied 90 kg on each face and it remained perfectly rigid (cube is 40x40 mm).

We are working hard on the next release of IceSL.One thing I really wanted to improve are the infill patterns. The 'sine wave' patterns we are currently using look fancy, but they have a number of severe drawbacks ; one of them is resonance on less robust printers, and another is a slow print time.

I have been thinking about this for some time now. What I wanted was: 1) something rigid (obviously!) 2) something that prints quickly 3) something that prints without putting stress on the printer and 4) something easy and fast to compute.

These requirements are quite high.

Regarding rigidity, I dislike that most infill patterns are simple extrusions along z. What is really called for is a pattern forming 3D cells inside the volume for maximum rigidity (side note: I just found about slic3r 3d honeycomb while writing this post, these look great ; there may be more prior work as I haven't checked in details yet - please comment if you know some).

Printing fast essentially means going along diagonals in straight lines - something IceSL doesn't do well currently. Avoiding stress on the printer also means moving as much as possible along straight lines (no vibrations, constant speed, constant pressure in nozzle). Unfortunately anything fancy (such as 3d honeycomb) quickly leads to some turns and broken lines. Finding out something simple and fast to compute just makes it harder. 

The idea. More than just a specific infill, this is a general way to build simple and fast to print 3D infills. Let me warn you this is, indeed, very simple (once understood) -- but I am unaware of anything like that in the slicers I know.

The initial intuition was to consider the walls of a regular axis aligned 3D grid. Now, we do not want that, because the horizontal planes would create flat surfaces. So, one possibility is to rotate the entire grid so that the diagonal of the cubic cells align with the z (up) direction. Take one slice through this rotated grid. The intersection is a pattern made of straight lines -- so that seems promising. At first sight, this also seems tricky to compute: the lines have to follow a very specific pattern and meet exactly at the right locations to form the 3D cells.

Well, it turns out this is in fact trivial. What is a regular grid? It is defined as the intersection of three sets of equally spaced parallel planes; the three sets having non-coplanar normals. In 2D, for instance, draw two sets of parallel lines: this forms a regular subdivision. You can even define coordinates in this grid by numbering the spaces between the sets of lines (planes in 3D).

There is no need to worry about the exact position of the planes: when you draw two sets of parallel lines on paper they always form a proper grid (as long as the two sets are not parallel). What this means is that we can easily produce an infill generating closed 3D cells simply by printing three independent sets of parallel planes!

This gets even better. In a slice each set of planes becomes a set of parallel 2D lines (see top of the print in image). Whenever we go up by one slice the position of the lines have to shift: each line is the intersection of a slice and a slanted plane in 3D. This can clearly be seen on the sides of the print, in the image above. What this means is that you can produce an infill forming 3D cells simply by tracing three independent sets of parallel lines in each slice! It suffices to make sure the lines shift correctly from one slice to the next, which is absolutely trivial to do.

For the initial tests I chose 2D lines which are angled at 0, 45 and 135 degrees so that 2 lines over 3 print diagonally (speed). The lines shift from one slice to the next to produce a 45 degree angle in 3D. All of this is easily controllable, the angle and spacing may vary for each direction and even between planes of a same set. More than three sets can be used to form more complex subdivisions.

The first prototype was coded in less than 10 minutes (!). Count on it for the next release of IceSL!

(Edit: if you include similar infills in your slicer, please cite this blog post, in the spirit of the CC BY license. Enjoy!)

[3dprint] New version of IceSL

We just released a new version of IceSL! Discover unique features such as implicit surfaces, print brushes, and slice shaders here: http://www.loria.fr/~slefebvr/icesl/ 


We now provide an installation package (Windows only) and IceSL will check automatically for updates!

[3dprint] IceSL Alpha 5_4

We just released a new version of IceSL (5_4).

IceSL now runs on most OpenGL 4.2+ hardware (NVidia, AMD, Intel HD). The release fixes a number of issues; here is the change log:

• Improved dense infilling (no gaps)
• Added support for SVG (see manual).
• Fixed bug with save/load of '.ice' format when the scene contains scripts.
• Improved cutting tool.
• An on-screen message is now displayed when the view cannot be rendered (inside object box).
• Fixed a rare bug producing a wrong bounding box for the object.
• Fixed a rare bug creating an invalid skirt.

Join us on the Google Group to discuss IceSL!

[3dprint] adaptive slicing and color mix

Some more thoughts on color mixing... One obvious thing to do is simply to slice adaptively, switching colors between layers. For instance, to get 70% of black and 30% of white, simply slice a 0.07 layer of black and then a 0.03 layer of white (thickness to be scaled depending on desired layer height). That is trivial to do in most slicers. Of course, to generate a spatially varying pattern in XY you need to change the slicing heights within the slice (in the XY plane), but this has been proposed before and does not seem too difficult to implement.

... maybe I should just try that!

[3dprint] More gradient examples

Two more examples of filament gradients. The slope -- in particular in overhang regions -- slightly changes the perceived color. The first model uses a linear ramp, while the second model uses a sine wave along the Z direction. I started experimenting with gradients along XY, first tests look promising.

[3dprint] filament gradients

I have been working on a way to blend two filaments together to achieve smooth gradients along a print surface. It is not perfect yet, but here is a brief description of this idea.

When working on our 'clean colors' technique, we made the observation that alternating layers of two filaments would produce different gradients of colors along the sides of the object. What happens is that the filament closer to the observer has more impact visually, than the one slightly behind. Interestingly, this paper made the exact same observation and came up with a very interesting way of depositing filaments to mix colors.

Starting from the same observation I came up with a different idea. Instead of changing the geometry I play with the flow of plastic. I do not alternate filament each layer but instead, at each layer, I deposit plastic twice (once for each filament) with a different flow of plastic. The two flows add up to 100% and by changing the percentage of each deposition you get different blends of colors. It is important though to always start by the filament having the highest percentage. What happens is that you get 'big' and 'small' cross sections of filament. And of course, the big one becomes more visible.

This works quite well and has interesting properties:
- the layer height is unchanged
- there is no change to the geometry of the print
The main drawback is that this requires carefull calibration to align the heads. This can be done in software by printing calibration tests. I have done initial experiments with spatial variations, but I yet have to explore this further. I am also curious to see what happens when doing this with soft/hard filaments and filaments of different properties.

If you experiment with this please let me know! If that works well enough we will include this feature in IceSL.