Michael's Homepage

about me teaching students research publications software


Architecture Overview


XGRT is a highly modular system, specifically designed for the requirements of a research environment. Its design is strongly object oriented and it uses structural reflection techniques to enable rapid prototyping of research code with minimal coding overhead for GUIs, scripting or storage. The system consist of several layers build on top of each other. The lower levels are independent of the higher level modules and can be used separately, for example for non-graphics related tasks.


XGRT Modules Overview

  • Foundation Layer: A reflective object oriented middleware that provides class introspection, and automatic serialization and GUI creation for C++
  • Math: A library for vectors, matrices, solvers for sparse and dense linear systems, eigenvalue problems
  • Geometric primitves: Libraries for triangle meshes, point clouds, volumetric representations. Support for huge out-of-core point clouds.
  • Rendering: Vertex/Pixel shader support for realtime rendering, including approximate global illumination effects.
  • Scene graph: A scene graph library to integrate different primitives into a scene representation.
  • Editor: An interactive editor for out-of-core point clouds.




The foundation module is the core of the system. It provides an object oriented middleware upon which all other system components are build. The objective of this module is the managment of modules, classes and their properties. The foundation library provides the following functionality:

  • Structural reflection: Unlike more recent programming languages such as Java, standard C++ does not provide extensive tools for structual reflection, i.e. to query available classes and their properties and methods at run time. The foundation library provides an easy-to-use and completely platform neutral library that implements reflection in C++. An extensive set of tools and macros keeps the additional overhead for using these mechanisms very low.
  • Class management: The structural reflection library is used to build an automatic class management system: the system inspects the class tree automatically to discover new functionality. For example, editing tools in the point cloud editor are all descendants of a specific class and all available decendents are provided automatically to the user for editing. In order to extend the editor it is sufficient to define a new class and dynamically load the new module.
  • Automatic GUI creation: Using the reflection mechanism, graphical user interfaces are created automatically for each class, allowing interactive inspection and editing of object graphs. This feature is especially valuable for rapid prototyping of research code. Manually created more involved GUI elements can be integrated seamlessly, if nessecary.
  • Automatic serialization: Arbitrary graphs of objects can be serialized automatically so that documents and data can be stored in files with minimum effort and guaranteed file integrity. The mechanism supports several versioning strategies to ensure compatibilities between files created with changing versions of the system.
  • Math: The foundation library also provides a rich set of mathematical tools for linear algebra, sparse and dense systems, eigenvalue problems, etc., implemented as efficient template library.

All other system components are build on top of the foundation module. The XGRT::foundation module might be useful as object oriented middleware for other, non-graphics applications as well.


The pointClouds library provides a set of containers for geometric primitives. In addition to point clouds, other containers such as triangle meshes and volume data sets are also supported. All containers are using run-time configurable attribute channels, which permit interactive definition of vertex, face, or voxel attributes. The containers use a common, abstract, iterator-based interface that allow generic processing of data. For example, conventional point clouds, hierarchical out-of-core point clouds, and triangle mesh vertices are accessed through the same polymorphic interface. Different iterator types (multiple interface inheritance) are used to provide access to different aspects of different types of data.


The rendering system provides support for hardware programmable shaders, hierarchical rendering and multi-pass rendering strategies. It uses the OpenGL interface with ARB shader extensions and nVidia CG for efficient and flexible rendering. Attributes defined in the geometric containers (xrt::pointClodus) can be bound to vertex shader inputs and textures at run time.


The scene graph library provides a hierarhical (directed acyclic graph) representation of scene objects. It provides a generic state model, state changing container nodes, hierarchical instantiation and geometric nodes. The state model is easily extensible, instantiation is freely programmable under arbitrary state changes and geometric nodes can carry generic data structures that exhibit certain data aspects (such as topology or control points) through the abstract iterator iterface. Access to the scene graph itself is also provided through abstract iterators that allow easy, modular and flexible data access.


The hierarchies module provides fully dynamic out-of-core multi-resolution hierarchies for point clouds. This module enables real-time rendering and editing of extremly complex point cloud modells. The technique is described in the Point-Based Graphics 2007 paper "Interactive Editing of Large Point Clouds".


The editor is a front end to the other XGRT libraries that provides interactive editing tools for various types of geometric data, including large out-of-core point clouds. The editor is build on top of the abstract iterator interface so that it is independent of the actual implementation of the geometry container. It uses accelerated algorithms for hierarchical data structures so that large amounts of data can be edited efficiently. The editor contains a module for efficient hierarchical queries (such as ray or cone queries in response to mouse selections) so that new tools that make full use of the efficient hierarchical data containers can be implemented with little effort.