Free Plugins

The Backup Plugin manages store and restore operations on objects. Plugins manipulating objects have to support backup and restore operations (which applies to all plugins in the free branch). It will add buttons and a history to OpenFlippers user interface to step through previous operations.

Backup and restore functionality in OpenFlipper is only available if this plugin is loaded.

The Data Control Plugin helps you to manage objects in OpenFlipper. It is used to show/hide objects, change their selection, copy, delete them or other properties. Additionally you can manage the object material via the context menu.

Included is also a way to group objects for handling larger scenes and a function to visualize object bounding boxes.

This Plugin can be used to decimate triangular meshes.

The decimation process can be controlled by several error constraints:

• Distance to original mesh
• Normal deviation
• Edge length
• Roundness of the triangles
• Aspect ratio of the triangles

The decimation order can be based on the distance, normal deviation or edge length.

Next to the incremental decimation, where the decimation is done in a sequential order by using a heap, we also provide a faster multiple choise decimation algorithm which is based on random samples. This algorithm is faster but still guarantees a minimum adjustable quality.

A mixture of both algorithms providing a good balance between speed and quality for large meshes is also included.

This plugin provides a dialog that allows the user to deserialize meta data from a viewer snapshot taken with "View" -> "Viewer Snapshot" (the "Store Mesh Comments" option must be on when taking the snapshot).

At a minimum, the viewport position and the materials used in the scene are restored when deserializing meta data with this plugin. If you attach your own meta data to your objects, you can implement one of the slots in MetadataInterface to handle that meta data once it gets deserialized from a viewer snapshot.

A typical scenario where this is used is, when you have a complex set of user set parameters used by your plugin to generate the scene seen in a snapshot. If your plugin serializes these parameters into the object meta data, it will be stored in the snapshot. Later, you can reproduce the exact same result by restoring the parameters from the meta data in the snapshot.

This plugin allows to import and export data in OpenFlipper via the Open Asset Import Library (Assimp). This adds a large set of supported file types to OpenFlipper. A list of the supported types is available on the assimp website.

This plugin reads and writes Biovision BVH files. This format can be used to store skeletal animation data.

This plugin is required to read and write Wavefront OBJ files. We support triangular and polygonal meshes as well as B-Spline curves and surfaces from OBJ files

This plugin is required to read and write OFF files.

This Plugin is required to read and write OpenMesh files.

This plugin is required to read and write PLY files.

This plugin is required to read and write STL files.

This plugin is required to read and write VTK files.

This plugin can be used to import image data as a height field. This is especially usefull for height maps stored as grayscale images. They can be converted to geometry by this plugin.

This plugin is based on the dynamic programming approach by Peter Liepa, , 2003, Filling holes in meshes. However, the algorithm handles the filling step in seperate blocks to avoid the O(n³) complexity. After the initial triangulation of the hole is computed, an optimization step improves the quality of the new mesh segment. Furthermore, the smoother plugin of OpenFlipper is used internally to get a smooth boundary and interior of the new patch.

The Info MeshObject plugin provides information about mesh objects.

The mesh objects can be either polygonal or triangular meshes. Next to simple information such as:

• #vertices, #edges, #faces
• #boundaries
• #components
• genus

This plugin provides also more detailed statistics:

• Vertex valence
• Edge length
• Aspect ratio
• Inner face angles
• Dihedral angles
• Object bounding box
• Center of gravity

The Info Skeleton plugin is used to display information about skeletons in the scene.

It provides statistics such as joint counts, attached animations and the current bounding box of the skeleton.

The Isotropic Remesher implements an incremental remeshing algorithm which remeshes a given triangular mesh so that all edges have approximately the same target edge length and the triangles are as regular as possible.

The algorithm used consists of 5 steps:

• Split all edges longer than the given target edge length.
• Collapse all edges shorter than the given target edge length.
• Flip edges to achieve an optimal average vertex valence.
• Move the vertices in their tangential plane to their center of gravity.
• Project vertices back onto original surface

The process can be iterated and it respects additional constraints such as features or boundaries. Vertices marked as features via the selection plugin will not be modified.

The material picker can be used to copy and paste materials between objects. The material information is retained when OpenFlipper is closed.

This plugin monitors GPU and main memory information. On the left it shows the current memory usage of the gpu while on the right it shows the main memory information. The statistics provided are system wide and not only the OpenFlipper usage.

The Mesh compare plugin can be used to compare meshes with respect to the following properties:

• Distance
• Normal deviation
• Mean curvature
• Gauss curvature

The plugin will visualize the difference as points and also provides a histogramm showing the result.

The mesh repair plugin can be used to identify and fix some common defects of meshes. It can:

• Detect and remove flat triangles (with valence 3 vertices in the center)
• Detect and remove skinny triangles
• Detect and remove triangles with one inner angle greater than a given threshold
• Detect and remove foldovers
• Flip the orientation of selected faces

Next to these repair features, the mesh repair plugin can be used to recompute vertex, halfedge and face normals of meshes. It also provides functions to snap vertices based on a given distance threshold.

The Move Plugin allows to apply affine transformations on objects or selections.

It provides the following transformations:

• Translations
• Rotations
• Scaling
• Shearing

The transformations can be applied to complete objects or only to a given selection. It has also functions to automatically scale objects to get a given bounding box size or to move the objects center of gravity into the origin.

Next to the input via a manipulator handled by the mouse, it is possible to set the transformation parameters in a context menu.

Poisson reconstruction based on the Code by Michael Kazhdan and Matthew Bolitho. The plugin requires points with associated normals. It is currently only usable on OpenMesh and SplatCloud based input, but should be easy to extend to other input data types.

This plugin can be used to provide stereo output on standard displays. OpenFlipper can render two images (one for the left eye and one for the right eye). If no special stereo display is available, the Anaglyph Stereo postprocessor can take the images, shift them to red and green and blend them together. The resulting image can be watched with red green glasses providing a 3D view of the rendered content.

Bilateral blurring takes the depth of the scene into account. It is possible to control the smoothness in spatial and depth range individually. This way edges can be preserved for example.

Next to the color image, the renderers produce a depth image describing the distance of each rendered scene pixel to the viewer. The Depth Image Postprocessor plugin replaces the final rendered color image in the viewer by the depth image. The depth values are mapped to a grayscale image in the postrocessing step.

Depth of Field simulates a lense model instead of a pinhole camera. Objects are blurred based on the distance to the plane in focus. Bokeh is a blurring effect that takes the shape of the camera aperture blades into account.
Depth of Field
Bokeh

The FXAA plugin implements an approximate anti-aliasing technique in a post processing step. Anti-aliasing is achieved by blurring the image along contrast edges.

[ Timothy Lottes, "FXAA", Febuary 2009 NVIDIA ]

The image is blurred with a standard seperable Gaussian filter.

This plugin takes the rendering output and removes the color from it. It uses the input brightness to compute the resulting grayscale values.

This plugin processes the rendered images to be displayed on Philips Autostereoscopic Displays. These Displays take a color image on the left and a depth image on the right. Additionally some flags (additional blue pixels) are added in the top left corner which are used to control the display behaviour.

Note: You have to switch OpenFlipper to fullscreen (Strg+F) when you use it on these Displays and this postprocessor has to be the last one in the postprocessor chain.

The image is blurred with a Poisson kernel. Samples in a Poisson kernel have a minimal distance to each other.

The image is blurred radially from a center pixel. Center and strength are controllable.

This postprocessor plugin takes the output image and applies a sobel operator to it.

The primitve Generator Plugin provides functions to create simple primitives in OpenFlipper.

It adds a menu to create the following objects:

• Cube (Triangle/Tetrahedral Mesh)
• Dodecahedron (Polygonal Mesh)
• Icosahedron (Triangle mesh)
• Octahedron (Triangle mesh)
• Pyramid (Triangle mesh)
• Cylinder (Triangle mesh)
• Sphere (Triangle Mesh, different parametrizations)
• Cuboid (Tetrahedral Mesh)

This simple plugin adds printing support to OpenFlipper. When triggered, it will make a screenshot of the current scene and send that to your systems printing system. You can choose which printer to use or send it to a pdf/ps file (if supported by the OS).

The Property Visualization plugin can be used to visualize various properties of triangular or polygonal meshes. The properties can be either scalar or vector valued and may be stored at vertices, halfedges, edges, and faces.

A color coder is integrated to get an optimal visualization of scalar valued properties. Vector valued properties can be visualized as lines or for example as colors based on the vector lengths.

The Remesher plugin can be used to reduce the complexity of triangular meshes. In contrast to the Isotropic remesher, it tries to adapt the triangle size with respect to curvature of the mesh. Therefore the resulting triangles will be large in flat areas while in areas with high curvature they will get smaller achieving a high precision output mesh with a low triangle count.

The user can set the maximal and minimal edge length of the output mesh and a maximal distance to the original mesh.

The default classical renderer implements rendering the scene of OpenFlipper with the fixed function pipeline of OpenGL.

It is suitable for most graphics cards and requires only OpenGL 2.0. Therefore the shader support of this Renderer plugin and the resulting pipeline is limited.

Requirements: OpenGL 2.0

This render plugin integrates deferred shading in OpenFlipper. Additionally, it shows how to perform full MSAA with offscreen render textures.

Requirements: OpenGL 3.2

The DepthPeeling plugin integrates order-independent transparency rendering in OpenFlipper.

Two variants of depth-peeling are implemented:

• The classical depth peeling approach which peels and blends each layer of the scene from front to back. [Cass Everitt, "Interactive Order-Independent Transparency", NVIDIA OpenGL Applications Engineering 2001 ]
• An optimized depth peeling technique peels the scene from both sides in parallel (front-to-back and back-to-front), which lowers the number of required scene passes.[Louis Bavoil, Kevin Myers, "Order Independent Transparency with Dual Depth Peeling", NVIDIA February 2008 ]

Requirements: OpenGL 3.2

The render normals plugin is used to take the current normals of the objects in the scene and render as colors. It is usefull to inspect the normal information during the rendering or as a result of a computation. As it works directly on the buffers, no additional functionality has to be added to the plugins.

Requirements: OpenGL 3.2

This is an order independent transparency renderer. The method first builds a linked list of all fragments in the scene. In a fullscreen pass, the list of fragments belonging to the same pixel is then manually sorted and blended in back-to-front order. This technique requires only one scene pass, followed by a fullscreen pass. ref: "OIT and GI using DX11 linked lists" by Nick Thibieroz & Holger Grün, presentation at GDC 2010

The picking renderer plugin can be used to visualize OpenFlippers picking buffers. The picking functions use standard color picking. This means that all primitives get rendered in their own color. On a mouse click, the color in the picking buffer at the current position is used to lookup the object and possibly which part of the object has been clicked.

The plugin just renders the picking buffer into the output color buffer.

Requirements: OpenGL 2.0

As opposed to the internal and classical renderer, the ShaderPipeline plugin implements the fixed fuction behaviour with shaders.

The combinatoric problem of dynamic states such as flat/smooth shading, texturing and light types is solved by dynamically generating and caching shaders for each combination while providing a high flexibility when adding additional shader code.

Requirements: OpenGL 3.2

The SSAO plugin approximates the ambient occlusion factor by locally sampling the normal and depth-maps of the scene. Sampling is done by randomly rotating offsets within a spherical kernel at each pixel. The occlusion factor is then obtained by comparing the sample position with the actual depth map of the scene. In a final pass, a downsampled and blurred image of the occlusion factor is blended with the color map of the scene.[ Vladimir Kajalin, ShaderX7 - "Screen-Space Ambient Occlusion"]

Image: Left w/ SSAO, Right w/o SSAO

The toon render plugin replaces the default lighting model with cel-shading and additionally outlines silhouettes in a post processing step.

In cel-shading, the diffuse and specular lighting factors are quantized to a fixed pallette. Silhouette outlining is achieved applying a sobel filter for edge detection.

Requirements: OpenGL 3.2

This plugin can be used to measure euclidean distances in the OpenFlipper view.

You can click at the start and the end point of the measurement and the plugin will visualize the distance between the clicked points. After you selected the starting point, the distance to the current mouse position will updated while you move it.

OpenFlipper provides a very flexible plugin system which can be used to automate tests or write entire new algorithms e.g. as combinations or modifications of existing ones. Each function in an OpenFlipper plugin can be easily made available as a scripting function (implement them as public slots).

The Scripting Plugin provides an interface to create scripts using these functions.

The interface of the plugin includes:

• Widget containing a list of all available scripting functions along with their documentation and parameters
• Live view showing functions which are called by the plugins(Has to be supported in the plugins)
• Editor with syntax highlighting, checking, and simple debugging

The script language is based on QtScript with is similar to javascript. For additional info see the Qt Documentation.

Note: If you want to use scripting in OpenFlipper, this plugin has to be loaded!

The Selection Base Plugin is used to add or modify selections on objects. It only provides the core functionality like selection metaphors. These basic information is then passed to lower level selection plugins which have to be implemented for each available datatype.

There are four types of selections which can be modified: Object-, Vertex-, Edge-, Halfedge-, and Face-Selection.

For all types the plugin adds different kinds of selection metaphors like Lasso-Selection( screen space and volume lasso) , Sphere-Painting-Selection, Boundary-Selection or Floodfill-Selection.

In addition selections can be converted between different types (feature selection, vertex selection, ...), stored to disk or colorized.

This plugin provides basic controls to animate skeletons in OpenFlipper. It can be used to switch and control the playback of animations.

Furthermore it allows to control skinning algorithms (Not available in the free version yet) to attach meshes to skeletons.

The Skeleton Editing plugin can be used to modify or create skeletons in OpenFlipper. It can add and remove joints from skeletons.

It is also used to move joints in 3D. The modifications can be either applied to:

• one single joint (in the current frame or in a whole animation)
• to the joint itself or the whole subtree of the joint

Furthermore a simple inverse kinematic implementation is provided to move the joints and modify their children and parents accordingly.

The Slicing Plugin can control the clipping planes in the renderers. If you want to look inside an object you can define a slice of the scene that is rendered instead of the full object. This is especially usefull for the volumetric datatypes like the ones based on OpenVolumeMesh.

The Smoother Plugin implements a laplacian smoother for triangular meshes.

The smoothing can be controlled by several constraints:

• normal/tangential direction or both
• C0 or C1 continuity
• Distance to original mesh
• Respect features (select them via the selection plugin first and convert them to features)

The Subdivider Plugin implements several subdivision algorithms for triangular and polygonal meshes (depending on the used algorithm):

• C. T. Loop, "Smooth Subdivision Surfaces Based on Triangles", M.S. Thesis, Department of Mathematics, University of Utah, August 1987.
• L. Kobbelt, "Sqrt(3) subdivision", Proceedings of SIGGRAPH 2000.
• "Interpolating Labsik Greiner Subdivider" as described in "Interpolating sqrt(3) subdivision" Labsik & Greiner, 2000
• "Modified butterfly scheme" of Denis Zorin, Peter Schröder and Wim Sweldens,
• "Interpolating subdivision for meshes with arbitrary topology'' in Proceedings of SIGGRAPH 1996, ACM SIGGRAPH, 1996, pp. 189-192.
• "Catmull Clark" subdivision

The Texture Control Plugin manages all textures in OpenFlipper. It enables the user to switch between different types of textures. OpenFlipper supports global textures which are available on all objects and visualize properties on the surface like e.g. curvatures(computed on demand to save computation time). For this scalar properties the plugin also offers a histogram to analyze and define ranges for rendering this values by using a texture. Additionally local textures are supported so that objects can be textured differently. The Plugin manages which texture is active on an object and allows to modify parameters for all available textures.

The Topology Plugin is a very simple one providing tools to change the topology of a mesh (triangular and polygonal). It can be used to split, collapse or flip single edges on a mesh. Furthermore it provides functions to add, delete and split faces. These operations are available via a simple mouse interface to allow the user to directly modify the topology.

This plugin adds a B-Spline Curve object type to OpenFlipper.

This plugin adds a B-Spline Surface object type to OpenFlipper.

Datatype to visualize cameras. It uses the camera settings such as projection matrix and modelview zu visualize a camera in the scene.

Simple data type for displaying coordinate systems. It provides a coordinate system at a given position and orientation. The type contains rendering routines and of course picking functionality.

This plugin adds a simple Plane object type to OpenFlipper.

This plugin integrates a polygonal mesh type based on OpenMesh into OpenFlipper. The facets in this type can have arbitrary valence (including triangles).

The type also provides efficient rendering.

Datatype plugin for skeletons. The datatype contains all functions to handle and render skeletons. The skeleton is implemented as a tree structure. It is possible to attach additional information to the primmitives.

Furthermore animation data can be attached and is controlled via the Skeletal Animation plugin. This way, skeletal animations can be directly visualized. Advanced plugins can use this information to deform meshes and create surface animations.

This plugin adds a simple Sphere object type to OpenFlipper.

This plugin integrates a triangular mesh type based on OpenMesh into OpenFlipper. It is only usable for strictly triangular meshes (non-triangular facets will be automatically triangulated when added to the datastructure).

This type is the basis for various OpenFlipper mesh processing plugins and also provides fast and efficient rendering.

The View Control Plugin manages the visualization of objects. It provides context menus to:

• Switch the objects draw modes
• Show/Hide selections, features, modeling area, ...

Furthermore it provides a toolbar with predefined views to be applied to the viewer. For the scripting system it implements various functions to control and get information about the camera, the rendering of the objects and other scene parameters.

The Visual Scripting Interface Plugin provides a visual programming interface to OpenFlippers scripting system. You can design algorithms by producing simple block/dataflow diagrams which are internally converted to OpenFlipper Scripts. Almost all freely available plugins provide blocks in the visual script editor which can be used to combine them to new algorithms or processing chains.

The editor also includes blocks for basic user interaction like dialog boxes.

Users without programming knowledge can use this interface to easily generate complex algorithms using existing function blocks.