The Open Volume Library

    Authors & Credits
    Sourceforge Page
    Freshmeat Page

    Design Document
    User Manual
    API Reference
    Plugin Document


    Code from CVS
    Browse CVS
    Report Bugs
    Feature Requests
    Mailing lists
    Getting Involved

Hosted At:
SourceForge Logo

Visits till now:


The following are the main features of OpenVL:
  • Plugin-based modular and extensible architecture
    Every feature in OpenVL is implemented as a dynamic plugin. You can write plugins to extend OpenVL at runtime. Each plugin is implemented as a shared library file that you can add to OpenVL's plugin directory and start using the functionality provided by the plugin. These plugins are loaded at run time when the functionality is desired, which leads to a small memory footprint for the library.

  • Access data using an iterator-like API
    OpenVL provides a single interface to access your volumetric data. This interface makes it trivial to implement algorithms on volumetric data. The interface provides functions to access and modify voxel data. By using this interface, your code becomes more robust since the functions check for boundary conditions. The code becomes more readable since the function name clearly shows what you are trying to do. The interface also allows you to access data that is stored in any layout.

  • Multiple storage layouts for volumetric data
    OpenVL allows you to represent you volumetric data in any layout you want. By layout we mean the way a volume is laid out before it can be accessed. So you can layout your data in linear layout (XYZ order), RLE (Run Length Encoded) layout or whatever way you can think of. The main advantage of different layouts is that they can save memory usage. For example, RLE layout for a medical data can save you considerable memory.

  • File Input/Output for a variety of file formats
    OpenVL can read and write data files in a varierty for file formats. File I/O for each of the supported file formats is implemented as a dynamic plugin. New plugins can be written which OpenVL and the applications using OpenVL can make use of dynamically. That is, OpenVL and the applications do not need to know anything about the new plugin. Simply drop the plugin file in the OpenVL plugin directory and all applications based on OpenVL will be able to read/write to the new file format.

  • Volume processing
    OpenVL includes a powerful framework for volume processing. By volume processing we mean any task that can be performed on a volume. This includes image processing, resizing, rendering etc. All volume processing tasks in OpenVL are implemented as dynamic plugins. New plugins can be used dynamically without recompiling the application code or the OpenVL code.

  • Easy sharing of plugins
    Since OpenVL plugins are single shared libraries, they can be easily shared among users. Just get the shared library of the plugin, drop it into the plugin directory and start using the features of that plugin!

  • Utility classes
    OpenVL provides all the utility classes that are needed when working with volumetric data. Some of these are math classes like vector, triple, normal, matrix etc. It also provides a clock class to time any process with a precision of 1 micro second. It provides a transfer function class which is needed for visualization. A histogram class is provided to get the histogram of any volume. A slicer class is provided to get any arbitrary slice of a volume.

  • Reduced compilation time
    OpenVL can significantly reduce the time you spend on compilation as most code is already compiled into the library. Since most features are implemented as plugins, any change to a perticular feature requires recompilation of the plugin only. If you implement your algorithm as a plugin, then you need to compile only your plugin when you modify your code. You do not need to touch your test program, other programs that use your plugin or the OpenVL library.

  • Smart use of templates
    OpenVL uses templates internally to supprort multiple datatypes and multiple layouts. But these are, for the most part, hidden from the user. This smart use of templates allows us to define interfaces that are free of templates and hence can be re-implemented by dynamic, run-time plugins.

Maintained by Sarang Lakare. Last modified February 08 2003 17:38:04.

© 2000-2003 Sarang Lakare

Valid XHTML 1.0!