Gamma

Gamma can perhaps best be described as a compiler collection for computational geometry. Although in terms of construction it is not really a compiler, its function nevertheless is to transform code, written in one of the supported languages, into geometry, which can be output in one of the supported formats. Currently, it supports two language frontends, Scheme (through Chibi-Scheme) and Lua and a rich set of operations on both polygons and polyhedra, including:

• simple primitive generation (polyhedra such as spheres and boxes, as well as linear, circular and elliptic polygons),
• exact boolean operations on both polygons and polyhedra,
• generalized polygon extrusion,
• other geometric operations, such as Minkowski sums, convex hulls, polygon offsetting,
• subdivision surfaces,
• mesh-oriented operations, such as remeshing, refinement, surface fairing and
• deformation operations.

Gamma was written with solid modeling for CAD/CAM applications in mind, but, being essentially a wrapper around a subset of CGAL, it might well be adaptable to other uses. Computations are generally exact and robust and although this can take its toll on execution speed, Gamma nevertheless strives for interactive use. It tries to achieve that through optimization at the language level (e.g. common subexpression elimination, dead code elimination, expression rewriting, etc.), at the execution level, (e.g. multi-threaded evaluation), and perhaps most importantly, by caching intermediate results, so that only the parts of the computation that have changed since the last execution need to be reevaluated.

Gamma is currently stable and, although not yet complete, it can already be used productively. Perhaps the most prominent missing feature, is a graphical inspector that can view the geometry as it is being developed (although there is currently some support for this through Geomview, on platforms where it is available). Apart from that, there's a host of useful geometric operations available in CGAL, which are not yet supported, but will be added in due time.

Which brings us to another missing piece...

Documentation

Well, there isn't yet any. Adventurous souls, who want to try out Gamma, might find some inspiration and guidance in the study of the code in the examples directory as well as the Orb trackball, a more complex design. I've tried to document these sources extensively, but Gamma is quite complex, so this is certainly no substitute. If you'd like to use Gamma, and are frustrated by the lack of documentation, open an issue to let me know (or post in an existing issue on the subject, if there is one). Writing documentation is not much fun at the best of times and knowing it will be of use to others can certainly help.

Building

Gamma should, in theory, be buildable on multiple platforms, but it is currently developed solely on Linux, so detailed instructions exist for that platform only. If you can build it for other platforms, please consider creating a PR, with build instrucitons and any other necessary changes.

Linux

Apart from the from the GCC compiler, with support for the C++ language, you'll also need CMake and Git. Use your distribution's package system to install them, then get Gamma's latest source via Git and prepare the build directory.

$ git clone https://github.com/dpapavas/gamma.git
$ mkdir gamma/build
$ cd gamma/build/

Gamma requires the following libraries, which should be installed via your distribution's package system (you'll need the development packages of course):

• GMP
• MPFR
• Boost
• zlib
• Eigen

In addition to that, you'll need CGAL and, although that might be available as a package as well, it would probably be a better idea to check out the latest stable release via Git, or perhaps even the master branch.

$ git clone --depth=1 https://github.com/CGAL/cgal.git

Depending on the language frontends you want to enable, you'll also need Chibi-Scheme and Lua. These are optional and if one is not available, the respective language frontend will be disabled. Here too, we will avoid system packages and instead build from source for static linking, as the system packages might not have been built with the appropriate configuration.

Chibi-Scheme is typically in flux and the latest stable release can be quite old, so it might be best to check it out from Git. Either use the master branch, or, if you prefer a bit less risk, you can use the master branch of the fork below, which will hopefully be kept pointing to a usable snapshot of the code.

$ git clone --depth=1 https://github.com/dpapavas/chibi-scheme.git

$ cd chibi-scheme
$ make clibs.c
$ make distclean
$ make libchibi-scheme.a SEXP_USE_DL=0 "CPPFLAGS=-DSEXP_USE_STATIC_LIBS -DSEXP_USE_STATIC_LIBS_NO_INCLUDE=0"
$ cd ..

To build Lua, get the latest release of the 5.4 branch and follow the instructions below:

$ wget https://www.lua.org/ftp/lua-5.4.4.tar.gz
$ tar -zxf lua-5.4.4.tar.gz
$ cd lua-5.4.4/src/
$ make CC=g++ liblua.a
$ cd ../..

Finally, if all went according to plan, you should be able to configure and build Gamma with:

$ cmake -DCMAKE_BUILD_TYPE=Release -DCGAL_ROOT=./cgal -DChibi_ROOT=./chibi-scheme -DLua_ROOT=./lua-5.4.4/src ..
$ make -j4
$ sudo make install

You can substitute a higher or lower number in -j4 above, depending on the number of cores and RAM available on your machine. The final command, will install Gamma in the default location (typically /usr/local). Consult CMake's documentation if you'd like to change this, or other aspects of the build.

License

Gamma is distributed under the terms and conditions of the GNU General Public License Version 3.