State: very early draft, just simulations
structure (using Cura solely as G-code viewer)
Updates:
- 2021/02/27: removed some redundant illustrations and remade some of them, outside-cone vs inside-cone mode & printing
- 2021/02/26: added inside-cone printing example for inner overhang mode, also early information of
slicer4rtn; more animations to observe details of produced G-code, using now also OpenSCAD to simulate G-code and actual nozzle position - 2021/02/24: better tests with 20mm cube and overhang structure, included two short G-code simulations as videos, added 20mm sphere and 3D Benchy and discover first issues with volume decomposition and overhang recognition
- 2021/02/23: first write up, pseudo code and first attempt to conic slice 20mm cube
Introduction
The main idea is to utilize existing 3D printing slicers but create conic slices for the Rotating Tilted Nozzle (RTN) 4 Axis Printer. ZHAW published in their announcement in 2021/01 something about utilizing existing slicers, but the details remained concealed and later published as a paper but I did not want to wait and pondered on the problem, and came up with a solution. In its current state it’s purely theoretical and untested for now (2021/02).
Non-Planar Conic Slices
The 4 axis Rotating Tilted Nozzle (RTN) physical setup implies its slices are of non-planar conic shape, allowing to print overhangs without support structure, such as:
I also like to master the conic slices properly as they promise to become a subset of 5 axis printhead (PAX) features too – so it’s worth the effort even if the RTN itself might be too limited in its application with its fixed tilt – we will see.
Theory
In a nutshell the steps are following:
- sub-divide faces of the model (fine-grained)
- map model to inverse conic space
- send to slicer
- remap G-code to conic space
- adding Zrot to G-code
Conic Space Mapping
(x1,y1,z1,rot) = conicSpaceMapping(cx,cy,x,y,z,dir);
whereas
cx, cyare the conic axis coordinatesx, y, zare the input coordinatesx1, y1, z1are the output coordinatesrotthe rotation anglex,yvscx,cydiris eitherdirect(default) orinverse
function conicSpaceMapping(cx,cy,x,y,z,dir='direct') {
dx = x-cx;
dy = y-cy;
d = sqrt(dx*dx + dy*dy);
rot = atan2(dy,dx);
return (x,y,dir=="direct" ? z-d : z+d,rot);
}Pseudo-Code
The entire procedure goes like this:
m = subDivide(loadModel("cube.stl"),5);
cx = m.minX + (m.maxX-m.minX)/2;
cy = m.minY + (m.maxY-m.minY)/2;
for(i=0; i<m.vertices.length; i++) {
m.vertices[i] = conicSpaceMapping(cx,cy,
m.vertices[i][0],m.vertices[i][1],m.vertices[i][2],'inverse');
}
writeSTL(m,"temp.stl");
exec("slicer","temp.stl","temp.gcode");
foreach(line of read_file("temp.gcode")) {
if ma = line.match("G1 Z([\d\.]+)") // new layer
z = ma[0];
else if (x,y,r) = line.match("G1 X([\d\.]+) Y([\d\.]+) (.+)") {
(x1,y1,z1,zrot) = conicSpaceMapping(cx,cy,x,y,z,'direct');
puts("G1 X${x1} Y${y1} Z${z1} A${zrot} ${r}");
} else
puts(line);
}Examples
I implemented the pseudo-code with some more details like taking care of G-code E extrusion as well and fine-step linear extrusion – here some early tests using OpenSCAD as STL & G-code viewer and Slic3r as actual slicer:
20mm Cube Conic Sliced
20mm cube 
20mm cube (inverse conic mapped) 
20mm cube (inverse cubic mapped & sliced) 
20mm cube (G-code direct conic mapped)
Snapshots of progress of conic sliced 20mm cube:
Overhang Conic Sliced
overhang model 
overhang model (inverse conic mapped) 
overhang model (inverse cubic mapped & sliced) 
overhang model (G-code direct conic mapped)
Snapshots of progress of conic sliced Overhang:
Gallery of Conic Sliced Models
Using Cura as STL and G-code viewer only:
overhang 2 (original) 
overhang 2 (inverse conic) 
overhang 2 (inverse conic sliced) 
overhang 2 (conic sliced) 
sphere (original) 
sphere (inverse conic) 
sphere (inverse conic sliced) 
sphere (conic sliced) 
3D Benchy (original) 
3D Benchy (inverse conic) 
3D Benchy (inverse conic sliced) 
3D Benchy (conic sliced)
Issues to Resolve
- test actual G-code in real life
verify, verified with G-code simulator coded with OpenSCADAxxx/ Zrot- verify
Exxxinterpolation
- find good pre-processing face sub-division strategy
- in its current form the algorithm requires fine-grained sub-divided faces otherwise inaccurate G-code is created which cannot be recovered
3D Benchy conic sliced with Original Faces 
3D Benchy conic sliced with Refined Faces
- slice more complex parts
- 3D Benchy: requires more thorough examination, e.g. volume decomposition to segment roof apart:
Impossible printing: current conic slicing needs to recognize overhangs and apply volume decomposition to choose right strategies – otherwise new issues arise which in Z planar slicing do not exist 
Same G-code position of the Inverse Conic sliced model: > 90° overhang created, and causes in-air structure – might require actual support structure (!!), volume decomposition required
- document all details
- release source code to public
Close-Ups
Some close-ups of conic sliced models:
20mm cube (partial) 
3D Benchy (roof & chimney) 
3D Benchy (cabin) 
Overhang model (top view) 
Overhang model (view on actual overhang)
Outside- vs Inside-Cone Printing
As pointed out in the previous blog-post, the RTN has two main modes of operation, outside-cone and inside-cone printing to cover outside overhangs and inside overhangs – the slicer must recognize those and switch operation mode. Further, these two modes cannot easily be mixed, and need to be segmented or separated, hence speaking of volume segmentation.
Outside Cone printing 
Inside Cone printing 
outer overhang 
inner overhang 
outside-cone printing for outside overhangs 
inside-cone printing for inside overhangs 
Inside cone for inner overhangs (bottom) vs
outside cone for outside overhangs (top)
This poses significant grow of complexity from just planar slicing, the 4 axis RTN provides features to print 90° overhangs without support structure, but only when the part can be properly analysed and segmented so that those operational mode can be applied.
The difference between inside- and outside-cone printing is to change the order of conic mapping for the model and post slicing:
outside-cone mode
- map model inverse conic
- slice model
- map G-code direct conic
inside-cone mode
- map model direct conic
- slice model
- map G-code inverse conic, Zrot + 180°
Slicer4RTN
The pseudo-code turned into an actual application I named slicer4rtn and is a command-line tool, slicing STL into G-code:
USAGE Slicer4RTN 0.0.4: [<opts>] <file.stl> ...
options:
-v or --verbose increase verbosity
--version display version and exit
--slicer=<slicer> set slicer (default 'slic3r')
-k or --keep keep all temporary files (temp.stl, temp.gcode)
--mode=<mode> set cone mode, either 'outside' or 'inside' (default: 'outside')
--output=<fname> override default naming convention file.stl -> file.gcode
examples:
./slicer4rtn sphere.stl
./slicer4rtn overhang-refined.stl --output=sample.gcode
and actual usage looks like this:
% ./slicer4rtn -v sphere.stl Slicer4RTN: processing 'sphere.stl' Slicer4RTN: #1/5 read stl Slicer4RTN: #2/5 map vertices Slicer4RTN: #3/5 write temporary stl Slicer4RTN: #4/5 slice stl Slicer4RTN INF: slic3r --skirts=0 --fill-pattern=rectilinear temp.stl -o temp.gcode => Processing triangulated mesh => Generating perimeters => Preparing infill => Infilling layers => Exporting G-code to temp.gcode Done. Process took 0 minutes and 2.188 seconds Filament required: 1946.9mm (13.8cm3) Slicer4RTN: #5/5 remap gcode to 'sphere-rtn.gcode' Slicer4RTN: done.
I gonna release slicer4rtn eventually, in its early version the model currently can only be sliced for outside-cone or inside-cone printing, so the volume decomposition or segmentation needs to be done separately.
References
- RotBot by ZHAW, the inventors of the Rotating Tilted Nozzle (RTN) approach lead by Michael Wuethrich
- Rotating Tilted Nozzle (RTN), my own approach
As I progress I will update this blog-post.
That’s it.
