opencamlib 2022.12.17

Drop-cutter

The drop cutter algorithm drops a cutter, positioned at a predefined (x,y) location, until it touches the 3D model.

Push-cutter

The Push-cutter is used to create a Waterline toolpath that follows the shape of the model at a constant z-height in the xy-plane.

Cutters

The algorithms listed above can be used with following cutters:

• CylCutter (flat end mill / cylindrical)

• BallCutter (ball end mill / spherical)

• BullCutter (radius end mill / toroidal)

• ConeCutter (tapered end mill / conical)

• CompositeCutter (combinations of the above / compound)

From August 2018 OpenCAMLib is released under LGPL license.

Python

The Python library (hosted on PyPi) can be installed like this:

pip install opencamlib

On some platforms, pip is called pip3, you might have to run:

pip3 install opencamlib

Note that pip / pip3 is will install packages for to the system installation of Python, if you want to install a package in a custom Python installation that is not in your $PATH (for example, the Python which comes with Blender), you can install packages like so:

/path/to/your/custom/python -m pip install opencamlib

Lastly, if you don’t know where Python is, but you have access to it’s interpreter (FreeCAD and Blender both have a Python console), you can simply enter this command in there to install opencamlib:

import sys; import subprocess; subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'opencamlib'])

JavaScript

The JavaScript library (hosted on npm) works in Node.js and the browser (by leveraging emscripten / WASM) can be installed like this:

npm install --save @opencamlib/opencamlib

Or, using yarn:

yarn add @opencamlib/opencamlib

C++

Precompiled C++ libraries are available on the Github Releases page (https://github.com/aewallin/opencamlib/releases). This project also installs a OpenCAMLibConfig.cmake, which, if your project uses CMake, allows you to use find_package(OpenCAMLib REQUIRED). You can see an example of that in use over here: examples/cpp/test/CMakeLists.txt

Dependencies

To compile OpenCAMLib, you need:

• C++ compiler (It should at least support C++ 14)

• Git (This is used for cloning the repository, and the emscripten SDK)

• CMake (At least version 3.15)

• Boost (When compiling the Python library, you have to compile Boost.Python for your Python version after installation)

At this time of writing, here are the packages to install:

sudo apt install -y git cmake curl build-essential libboost-dev

brew install git cmake curl boost python@3.11 boost-python3

Building for C++

The C++ library is the easiest to build, it only depends on Boost’s headers. Make sure you have a compiler, git, cmake and Boost installed (or simply download and extract it somewhere).

git clone https://github.com/aewallin/opencamlib
cd opencamlib
mkdir build
cd build
cmake .. -D CXX_LIB="ON"
make . # try make -j4 for a faster build if you have a multi-core machine
make install .

When boost is not in a standard location, you can add the -D BOOST_ROOT=/path/to/boost option to the cmake command.

Building for Emscripten

To compile the emscripten library, first download, install and activate it using the following commands:

git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install latest
./emsdk activate latest

Now you can compile opencamlib like this (make sure to replace the path/to/ sections):

source path/to/emsdk/emsdk_env.sh
git clone https://github.com/aewallin/opencamlib
cd opencamlib
mkdir build
cd build
emcmake cmake \
  -D CMAKE_BUILD_TYPE="Release" \
  -D BUILD_EMSCRIPTEN_LIB="ON" \
  -D USE_OPENMP="OFF" \
  -D CMAKE_INSTALL_PREFIX="/path/to/opencamlib/src/npmpackage/build" \
  -D BOOST_ROOT="/path/to/boost" \
  ..
emmake make # try emmake make -j4 for a faster build if you have a multi-core machine

Note that USE_OPENMP has been turned off, OpenMP is not supported with Emscripten at the moment

Building for Node.js

To compile the Node.js library, install the dependencies in src/nodejslib:

cd src/nodejslib
npm install

Next, use cmake-js to compile the library:

git clone https://github.com/aewallin/opencamlib
cd opencamlib
mkdir build
cd build
../src/nodejslib/node_modules/.bin/cmake-js \
  build \
  --directory ".." \
  --out "." \
  --parallel 4 \
  --CD BUILD_NODEJS_LIB="ON" \
  --CD USE_OPENMP="ON" \
  --CD CMAKE_INSTALL_PREFIX="/path/to/opencamlib/build/Release/$(node --print 'process.platform')-nodejs-$(node --print 'process.arch')" \
  --CD BOOST_ROOT="/path/to/boost" \
  --config "Release"

Building for Python

The Python library can be compiled similarly to the C++ example above, however, this time Boost.Python has to be compiled first. Most systems have Boost.Python available as a download, but only for a specific Python version only (usually the latest Python version). These might work if you are using Python from the same package, unfortunately, this is not a very reliable method, so compiling them yourself is usually the best option.

First, download and extract Boost:

curl "https://boostorg.jfrog.io/artifactory/main/release/1.80.0/source/boost_1_80_0.tar.gz" --output "boost_1_80_0.tar.gz" --location
tar -zxf boost_1_80_0.tar.gz -C /tmp/boost
cd /tmp/boost/boost_1_80_0

Now we can compile it:

echo "using python ;" > ./user-config.jam
./bootstrap.sh
./b2 \
  -a \
  threading="multi" \
  -j4 \
  variant="release" \
  link="static" \
  address-model="64" \
  architecture="x86" \
  --layout="system" \
  --with-python \
  --user-config="./user-config.jam" \
  cxxflags="-fPIC" \
  stage

Note that you can customize the user-config.jam file to point it to your Python installation (see: https://www.boost.org/doc/libs/1_78_0/libs/python/doc/html/building/configuring_boost_build.html). You should also specify the correct architecture and address-model. On windows, make sure to use windows style paths, e.g. C:\\path\\to\\Python

Could NOT find Boost (missing: Boost_INCLUDE_DIR)

This happens a lot, here are some of the reasons why this happens:

You don’t have Boost installed.

If you forgot to install boost, go ahead and download Boost from from their website: https://www.boost.org/users/download/ and extract it somewhere. Now, when compiling the C++ or node.js module, add the

-D BOOST_ROOT=/path/to/extracted/boost flag to the cmake .. command, or the.

--boost-prefix /path/to/extracted/boost flag to the ./install.sh command

You installed Boost from Github.

The boost that is hosted on Github does not have the headers yet! To compile those, you should run the following commands:

./bootstrap.sh
./b2 headers

Your CMake version has a FindBoost module which is unaware of your Boost’s version.

The CMake module that looks for Boost, is usually not aware of the existence of the latest Boost versions. You can help it by providing the version number of your Boost with the -D Boost_ADDITIONAL_VERSIONS="1.80.0" flag. Make sure to change 1.80.0 with your version of Boost.

It can also be helpfull to enable Boost_DEBUG in the CMake configuration.

macOS

Cross compiling on macOS is possible by setting the CMake CMAKE_OSX_ARCHITECTURES flag. When using the install.sh script, you can use the --macos-architecture flag to accomplish the same thing. Make sure to take a look at the other --*-architecture flags when cross compiling.

Windows

Cross compiling on Windows is possible by using the “Visual Studio” generator (default) and by setting the CMake CMAKE_GENERATOR_PLATFORM flag. When using the install.sh script, you can use the --cmake-generator-platform flag to accomplish the same thing. Make sure to take a look at the other --*-architecture flags when cross compiling.

Linux

To ensure that compiled libraries work on older linux versions, it has to be compiled with an older Glibc version. The easiest way to accomplish this is by using Docker, there are images available especially for this purpose. When using the install.sh script, you can use the --docker-image flag which will make the command run in a container with the given image name.