Free Tools for Fabrication
Here are my notes on free tools which can be used to drive the
fabrication machines. I've split the list into functional groups of
applications, and have notes on what an ambitious hacker could do to
make each of these programs even better for our use.
Needed: a 2D drafting program that has object snap facilities,
allows specification of exact dimensions, boolean shape/path
operations, exports to useful formats (DXF/AI), and ideally allows
parametric specification of dimensions so that, for example, you can
globally specify a new fit tolerance and have all the parts updated
accordingly. The non-free tool here is CorelDraw 10; Corel has a
CorelDraw 9 for Linux. CorelDraw doesn't do parametric
dimensioning (as far as I can tell); it has all the other desired
Free software alternatives:
- Inkscape (C/C++).
I just discovered this program (Apr 2004) but it seems very nice.
Exact dimensioning and boolean operations are supported.
Parametric specification of dimensions doesn't seem to be supported
(yet?). It reads and writes SVG; but I've got tools for converting
SVG to DXF. I think this is the "way of the future", and if I were
to hack on something, I'd spend my effort adding parametric
dimensioning to Inkscape and writing more SVG conversion tools.
- OpenOffice (C).
This is a functional equivalent of CorelDraw -- it's even nicer in
some respects: when you type in a new dimension for a shape, you can
specify which point you want anchored for the resize (I had a part
ruined on the laser cutter when I resized my axle hole and CorelDraw
decided to anchor the top left corner, not the center).
The output formats are a little limited: there are lots of raster
formats, but the only vector formats supported are EMF, EPS, MET, PCT,
RAS, SVG, and WMF. I'd like to see DXF or Adobe Illustrator formats.
I'll update this item after I've had a shot at making an OpenOffice
document play nicely with the laser cutter.
(Thanks to Bryce
Harrington for the pointer!)
- QCad (C++/Qt3). A basic
DXF-in/out 2D cad package. Very easy to use. All the desired
features, but the parametric dimensioning is very limited: you
can create shapes which are stretched by a specified amount on
import. It can create arcs and circles but not ellipses or
beziers, which may or may not be a severe limitation for you.
- Sketch (Python and C/GTK).
This is a
fairly complete vector drawing program with a nice UI.
It allows object snap and
exports to a variety of formats; it is also based on Python with
a plugin interface so extension and mathematical shape description
should be easy.
It does not seem to have UI for specifying exact
dimensions of shapes; this seems like it would be a simple hacker
Boolean shape operations are currently implemented incompletely
as an extension called
PathUtils; implementing this within sketch completely (and correctly?) is
included in the TODO
file for version 1.0. Finishing the details to make this a
useful CAD tool seems like a good project for a motivated Python hacker.
- Kontour (formerly
known as "KIllustrator") (C++/KDE). Another drawing program with a nice
UI. It is missing boolean shape/path operations, object snap, and
parametric dimensioning. Its set of export formats is quite limited
- Xfig (C/X). This is the stable
grand-daddy of Unix drawing programs. Its native file format is
well-documented, which makes it very easy to write programs to
mathematically generate fig drawings. It is easy to specify exact
dimensions, but object snap, boolean path operations, and parametric
dimensioning are all missing. Adding these features would again be a
good hacker project.
- Sodipodi (C/GNOME).
Uses SVG as its native format; I'm not sure if this is well-supported
by other tools as an input format. It also has a very eccentric user
interface. Its features and missing features are otherwise the same as xfig.
- Dia (C/GTK+).
This is a diagramming tool like the Windows program "Visio". It
has very good export support, but seems to be missing exact
dimensioning, object snap, and boolean shape operations.
Other useful tools for 2-d drafting:
- AutoTrace (C).
This program converts bitmaps to vector graphics. This is great for
taking scanned or found artwork and converting it into paths for
the laser cutter or waterjet. Helpful hint: make sure your input
graphics are black-and-white only --- no grayscales!
Grayscales look smoother on the screen, but autotrace tries to create
a separate contour for each color in the shading, leading to
Here's a typical session with AutoTrace:
This image was pulled from the web.
I scaled it up by a factor of two, converted to
black-and-white and touched up a few pixels to get this image.
I then opened up all the closed
areas in the image (the bits that would become unsupported if I cut
along the edges of the black areas).
Running AutoTrace on the above then gave me
this beautiful smooth and scalable version of
the graphic. If your browser can handle SVG, you might be able
to scale this version up and down.
Smoothness that just won't quit!
- A similar tools is potrace, which I actually
like even better. There's a
paper by Peter
Selinger describing the principles upon which it is based;
I used this for my stained glass project.
3D parametric modelling
You may also be interested in ViewSTL, an
open-source program for Linux/IRIX/Windows to let you
view STL files (such as those for the Modela or the 3-D printer).
- Art of Illusion (Java).
This seems the most promising, with a very nice UI, but I haven't
gotten enough experience with it to determine if the underlying
representations are suitable for engineering/fabrication work.
(C/X). "Constraint-based scene design." The underlying parametric
engine looks sound, but it doesn't look like exact dimensioning is
exposed by the GUI. The export formats are limited to rendering engine
input formats and VRML, which is likely insufficient for driving
fabrication tools. Constructive Solid Geometry is supported.
All arcs are converted to
lines at a rather coarse granularity; it is hard to determine if this
is part of the underlying representation (bad) or just an artifact of
the on-screen renderer. The GUI as a whole is rather poor.
- BRL-CAD (C/Tk). Looks
capable, but you have to sign a rather evil license agreement with the
US Military before you can see source or binaries.
- Graphite is
a "research platform for computer graphics, 3D modeling and numerical
geometry". It is licensed under the GPL. I haven't tried this yet,
but it may well be useful.
Schematic capture and PCB design tools
I use XCircuit
for schematic capture and PCB for PCB layout.
The current alpha version of PCB has an auto-router I wrote which Works For
Me. XCircuit stores schematics in Postscript; PCB exports to Gerber
files. You can send the gerber files directly to
Alberta Printed Circuits to
have them fabricated, or use my Gerber
tools to drive the Roland CAMM-1 (at present) or
milling machine (eventually).
Some schematics I drew with XCircuit
Corresponding circuit boards created with PCB
The gEDA project has what
look like very nice schematic
applications; there are also circuit and verilog simulators, waveform
viewers, and gerber previewers in the project. In particular, the Icarus
Verilog compiler seems to be undergoing very active development
at the moment. I'd be very interested in hearing the experiences of
anyone who's done a complex schematic in gschem and used it to create
a PCB design.
You could conceivably use Dia (see above) to do
the schematic capture, but Dia doesn't seem to export netlists, which
means your schematics may be pretty, but they're useless for making
printed circuit boards from.
Other schematic capture tools include:
abandoned, but talks to SPICE well), and
Gael (as of this writing
Programming libraries and file formats
- OMAX File formats (RTF).
Details the DXF and ORD file formats used by the OMAX waterjet.
- OpenCascade (C++).
This is not an application, it's a set of application development
libraries for 3D modelling, including file import/export and all
the complicated NURBS, etc, functionality. However, OpenCascade
has its own
peculiar license. It seems to be a GPL-alike, but I'm
not a lawyer. Your milage may vary. It also seems to be a very large
body of code, perhaps unmanagable for casual hacking --- but there
is an existence proof that
this is possible.
- DIME (C++). DIME is a DXF
file format support library. It does not contain any rendering
methods; it is designed for input/output processing.
- OpenDWG. This web site contains
the official format spec and promises tools, utilities. No libraries
unless you're a member of the "alliance", though.
- Information on other file formats: Gerber,
Copyright © 2002 C. Scott Ananian.
Verbatim copying and distribution is permitted in any medium,
provided this notice is preserved.