Friday, August 5, 2016

[3dprint] hierarchical rhombic infill

Rhombic infills are both strong and fast to print. If you are using IceSL, you probably already have seen these patterns as they have been the default infill for the past year. I also did a number of experiments with a hierarchical version of a rhombic infill. However, the question of how to select the subdivision level depends on the target application.

A recent article by Wu and colleagues explores interesting ways to subdivide a rhombic infill to strengthen objects, for instance using a finite element simulation to subdivide weak areas in priority. This increases the density of the structures locally to obtain stronger parts.

Beside their good properties (self supporting and mechanical strength), rhombic infills are also very efficient to generate and print. Our web based slicer, SliceCrafter, includes an improved rhombic infill that prints very fast because it only uses 45 degree angled print paths (an idea suggested by IceSL user Maze Mietner). Try it out!

Wednesday, June 15, 2016

[3dprint] Plastic deposition flow control in IceSL

IceSL has a nice feature to control plastic flow that I never took the time to explain.

There are several ways to produce the toolpaths for plastic deposition, and some of them result in paths that can slightly overlap : if you were to follow the paths with a thick marker, some places would receive color twice. Well, the same happens with plastic resulting in overflow! The reason a slicer might want to do that is to avoid the opposite: leaving a gap. IceSL tends to squeeze more paths within a slice so as to reduce some of these gaps (it is not perfect though, as some thin walls are still problematic).

While often small, if such overflows occur always at the same place across layers, they will accumulate and result in bad looking 'bumps' (or worse, the nozzle will collide with the part).

The 'flow' module of IceSL takes care of this. It uses OpenGL rendering tricks and follows the path with the virtual equivalent of a marker. Only, in each pixel it counts how much color (plastic, really) is deposited. If this amounts exceeds the target, it tunes down the extrusion rate so has to avoid overflow. This works quite well in practice! I believe this could also be used for SLA / laser engraving where 'beam energy' can also accumulate more than desired (the beam footprint is not an exact dot, but rather a small circle).

The two images at the end of the post show a slice before flow optimization, and the same afterwards. The grayscale levels indicate a reduction of the plastic flow ; they are especially visible in the thin areas (you might have to zoom in to appreciate the changes.

Now is this the best way to do this? Possibly not ; geometry analysis of the path thicknesses could be faster than the brute force GPU approach -- which is also quite approximate.

I am currently exploring better ways to limit gaps and overflows in IceSL. Stay tuned!

Sunday, January 31, 2016

[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!

Tuesday, July 28, 2015

[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!)

Wednesday, March 18, 2015

[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: 

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

Wednesday, September 10, 2014

[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!

Tuesday, May 27, 2014

[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!