This tutorial will introduce the basic concepts behind the OpenMesh Python Bindings.
We will cover the following topics:
In addition, we will briefly discuss some of the differences between the Python Bindings and the original C++ implementation of OpenMesh.
The Python Bindings depend on the following libraries:
The Python Bindings are automatically built with OpenMesh. The generated files are written to the Build/python subdirectory of the build tree. For more information on how to build OpenMesh see Compiling OpenMesh.
If CMake does not find your Python installation (or finds the wrong one) you can explicitly specify an installation by setting the following variables:
PYTHON_LIBRARY - Path to the python library PYTHON_INCLUDE_DIR - Path to where Python.h is found
Similarly, if CMake does not find your Boost Python installation, set the following variables:
BOOST_ROOT - Preferred installation prefix BOOST_INCLUDEDIR - Preferred include directory e.g. <prefix>/include BOOST_LIBRARYDIR - Preferred library directory e.g. <prefix>/lib
To use the OpenMesh Python Bindings we first need to import the openmesh module:
The module provides two mesh classes: One for polygonal meshes (PolyMesh) and one for triangle meshes (TriMesh). You should use triangle meshes whenever possible, since they are usually more efficient. In addition, some algorithms are only implemented for triangle meshes while triangle meshes inherit the full functionality of polygonal meshes.
The following code creates a new triangle mesh:
We can add a new vertex to the mesh by calling the add_vertex() member function. This function gets a coordinate and returns a handle to the newly inserted vertex.
To add a new face to the mesh we have to call add_face(). This function gets the handles of the vertices that make up the new face and returns a handle to the newly inserted face:
We can also use a Python list to add a face to the mesh:
Now that we have added a couple of vertices to the mesh, we can iterate over them and print out their indices:
We can also iterate over halfedges, edges and faces by calling mesh.halfedges(), mesh.edges() and mesh.faces() respectively:
To iterate over the items adjacent to another item we can use one of the circulator functions. For example, to iterate over the vertices adjacent to another vertex we can call mesh.vv() and pass the handle of the center vertex:
We can also iterate over the adjacent halfedges, edges and faces:
To iterate over the items adjacent to a face we can use the following functions:
OpenMesh allows us to dynamically add custom properties to a mesh. We can add properties to vertices, halfedges, edges, faces and the mesh itself. To add a property to a mesh (and later access its value) we have to use a property handle of the appropriate type:
The following code shows how to add a vertex property to a mesh:
The second parameter of the function add_property() is optional. The parameter is used to specify a name for the new property. This name can later be used to retrieve a handle to the property using the get_property_handle() member function.
Now that we have added a vertex property to the mesh we can set and get its value. Here we will use the property to store the center of gravity of each vertex' neighborhood:
Properties use Python's type system. This means that we can use the same property to store values of different types (e.g. store both strings and integers using the same vertex property). Properties are initialized to the Python built-in constant None.
To remove a property we have to call remove_property() with the appropriate property handle:
Another way to add and remove a property is to use a property manager. A Property manager encapsulates a property and manages its lifecycle. A Property manager also provides a number of convenience functions to access the enclosed property.
There are four different types of property managers. One for each type of mesh item:
Property managers automatically add a new property to a mesh when they are initialized. Thus the following code not only creates a new vertex property manager, but also adds a new vertex property to the mesh:
Property managers allow us to conveniently set the property value for an entire range of mesh items:
They also allow us to use the subscript operator to set and get property values. Here we will once again use a property to store the center of gravity of each vertex' neighborhood:
Properties that are encapsulated by a property manager are automatically removed from the mesh when the property manager goes out of scope (i.e. the property manager is garbage collected).
You can read and write meshes from files using the read_mesh() and write_mesh() functions:
The file type is automatically deduced from the file extension. OpenMesh currently supports four file types: .off, .obj, .stl and .om
The behaviour of the I/O functions can be controlled by passing an instance of the Options class to either read_mesh() or write_mesh(). The class controls the behaviour of the I/O functions by means of enabled/disabled bits in a bitset:
Other available option bits include:
When reading a file the options are used as hints, i.e. depending on the format we can help the reader to interpret the data correctly.
When writing the mesh the mode bits control whether to use the binary variant of the respective file format and the desired byte-ordering.
You can use our unit tests to learn more about the OpenMesh Python Bindings. They are located in the src/Python/Unittests subdirectory.
The interface of the Python Bindings is to a large extent identical to the interface of the original C++ implementation of OpenMesh. You should therefore be able to use the C++ documentation as a reference for the Python Bindings. In particular, the classes KernelT, PolyMeshT and TriMeshT provide a good overview of the available mesh member functions. That being said, there are a number of small differences. For example, whenever the C++ implementation returns a reference to an object that is managed by OpenMesh, the Python Bindings will return a copy of that object. This is due to the fact that Python does not have a language feature that is analogous to C++ references. One example of such a function is the point() member function of the PolyMesh and TriMesh classes. Unlike its C++ counterpart, the function does not return a reference to the requested point. It instead returns a copy of the point. This implies that you have to use the set_point() member function to change the value of a point. The same applies to the following functions: normal(), color(), property(), status(), etc.
The complete source looks like this: