InkscapeHowto

This page describes an "easy" way to convert Inkscape paths to gcode files.

• Inkscape is a 2D drawing program that can be used for drafting
• Paths are the drawing elements.
• Inkscape can manipulate bitmaps, fonts and objects, all of which can be converted to paths.

Setup of Inkscape (and gcode scripts) on Ubuntu

• From Ubuntu 6.06's package manager, install Inkscape 0.43
• With root priviledges, copy the following files
  • upload:gcode.inx
  • upload:gcode.py

to your /usr/share/inkscape/extensions directory. Rename those files to gcode.inx and gcode.py.

• Enable effects: In Inkscape, open the preference page (SHIFT+CTRL+P), select the misc tab and check "Enable script effects".

• Restart Inkscape, you should now see a "Effects" menu with a "Export as GCODE" entry

How it works

• The idea is that the "Effect" will generate a gcode file (inch mode) for the SELECTED PATHS
  • SELECTED: if nothing is selected, you get a useless gcode file
  • PATHS: this effects works only on paths, so "objects" must be "converted to paths" (SHIFT+CTRL+C) and "text" must be converted to paths, bitmaps must be traced (SHIFT+ALT+B), groups must be "ungrouped" etc.
  • Styles, strokes, color and other properties are ignored.
• Paths are converted to straight lines using G01 codes.
  • This seems is perhaps a huge limitation
  • One reason is that the author is very lazy,
  • He doesn't understand Bezier maths and control points
  • There are too many tunable parameters (how many segments to use, etc)
  • He found out that Inkscape has great tools to add/remove nodes.

Tutorial

• Draw a shape (or object, text etc... but don't forget to convert to shape) ... like this:

• Don't use the "Export as GCODE" effect just yet, or you'll get a result like that:

• Use the "Add nodes" effects to control the fidelity of your GCODE. You can also select nodes and the "make selected segments lines" tool to have the best idea of what your shape will look like.

• Select the "Export as GCODE" effect from the "Effect" menu, and go wild on the effects parameters.

• Voila, an easy way to go from vector to EMC.

Feedback

Please edit this section of the page to provide feedback. In particular, I am interested in finding out if it would be best to add a curve interpolation to the effect.

• Pros
  • The paths would be kept simple in the svg file, because node count could be limited.
  • The GCODE would "look" better, and SVG files would not require editing. This is good for clipart, where the author is not the machinist.
  • SVG paths are supposed to be "curvy". Using them as straight segments is an ugly hack.
    • I'd disagree, CNC (including EMC) moves in very short straight lines at the lowest level, so making the line segment very short approaches or surpasses the granularity of the trajectory planner. This makes the path as true to the original as possible. It makes a long program of tiny moves. Caveat: if you choose a unit length (1) be prepared for Inkscape to 'go away' for a while, it does not show a 'busy' indication. ;)
    • i double dog disagree. any curve interpolation should use [biarcs] - emc supports arc interpolation and we might as well use it. this would keep it 'curvy' but still limit the number of lines to a reasonable amount, and as a bonus you get a perfectly smooth acceleration profile. using line segments clogs the tp queue (slows machine down) and will never approach the same level of smoothness as a biarc path.
• Cons
  • The effect would have to make decisions about how many lines should be used in each curve segments, and the magic numbers or unintuitive parameters would have to be typed in (aka: 'precision', 'quality', 'longest segment length'), or derived by the script (with euristics to decide the 'straightness' of a segment based on its length and control points).
  • Unlike other vector to GCODE converter scripts, the user has a good control on the output. He can decide exactly how many segments he wants, because Inkscape has a good set of node editing tools. It gives the user the ultimate control, because he is not a victim of a converter's built in assumptions (a.k.a magic numbers).
  • Using a custom interpolation scheme could sometimes produce results that are different to the original. As a result, path intersections may look different in the GCODE than on the SVG application.
  • If Inkscape's skew transforms are applied, the output is not transformed. I chose a spiral, stretched it, chose translate|rotate 45 deg, path|object to path, effects|add nodes, length 1.0, effect|export as gcode, chose 0 offsets , pushed it thru sim-servo (axis) and it's not rotated or stretched. The nodes are contained in a 'g', and the 'g' is wrapped in the transforms. Looking at the nodes will overlook the transforms. This is like mirroring and scaling on a cnc, the path is the same gcode, but the gcode is wrapped in a scale or rotate.
    • I have patched [gcode.py] and [gcode.inx] in order to consider the scale and translation specified in the path transformation matrix.I have converted also the units and the output gcode in metric scale.

Perhaps the best approach is some kind of middle ground.

GlenHarris?: I have modified these scripts to create a slightly different version. This version honors the units of the inkscape document, so there shouldnt be any scale problems (i.e. mm vs inches - dont know about the transformation issues hinted at above). The other main change is that it will output information in layers, see the help for the effect for more details. Also, this has been set up with a framework so that we can add automation conversion from beziers to straight lines or arcs (to within machine tolerance). You can call this effect in two ways:

• 'Save As EMC GCode': This will create a single .nc file containing all the layer toolpaths.
• 'Effects|Export|Export as GCode': This will output one file per layer in a specified directory.

Here are the files:

• upload:export_gcode.inx
• upload:export_gcode.py
• upload:saveas_gcode.inx

GlenHarris?: OK, we now have the '2.0' version of Inkscape Gcode generation. The most important change is that it will now output some shapes (e.g. rounded rectangles) directly, and it can now export bezier curves. Bezier curves are linearly interpolated to machine resolution - a future extension would be to use arcs instead.

The code has been set up in a [repository] so that if anyone can contribute further changes they are welcome. To install, grab either the .zip or .tar.gz from here:

• [Bitbucket inkscape-gcode dist tip]

This file should be unzipped into your '/usr/share/inkscape/extensions' or 'C:/Program? Files/Inkscape?/Share?/Extensions?' directory. You can call this effect in two ways:

• 'Save As EMC GCode': This will create a single .nc file containing all the layer toolpaths.
• 'Effects|Export|Export as GCode': This will output one file per layer in a specified directory.

Make sure you read the help carefully because it will explain how to label layers etc.