The Vish Visualization Shell  0.3
Vish
VISH
See also
Overview of Documentation Pages for an overview of available documentation.

What is Vish?

The primary purpose or Vish is to provide a framework ("shell") to implement and run modern, hardware-optimize algorithms for scientific visualizations in a user-friendly environment deliverable to end-users such as application scientists. The Vish framework has been designed such that each part of the provided high-level functionality can be overridden with application-specific low-level functionality without impacting other components. It is general enough to be applicable to a wide range of usages beyond its primary domain.

Vish follows a library-centric approach providing a minimal set of kernel capabilities with an extensive set of plugin options. Each functionality domain (such as OpenGL rendering, graphical user interface, scripting, data I/O) is hereby strongly encapsulated and implemented independently from each other, communicating via highly performant abstraction layers. Vish is available under the Light++ Copyright license.

Vish by itself is not an application but a collection of libraries and plugins which can be incorporated into another application. These applications implement the various interfaces as specified by vish. The vish plugins, which are compiled using solely the vish interfaces into shared library modules, will then be binary compatible among all applications and can be shared among them on the same hardware platform (with restrictions merely imposed by usual limitations of C++ binary compatibility). An advanced application built upon Vish is qVish, which uses QT as graphical user interface to expose the full capabilities of Vish.

Core to Vish is the concept of a Vish Object (VObject, see VishObjects), which is an abstract entity as part of a visualization pipeline (or data processing pipeline, in general). Vish objects process data and may have input and output data, which may be as simple as an integer or floating point number, or as well complex user-defined data structures.

A special subclass of vish objects are render objects; these may provide OpenGL code to perform actual data display. Vish provides an higher-level abstraction layer to rendering, the Anemonia API, which allows rendering independent of actual OpenGL code and lets an implementation (of the Anemonia API) do the actual mapping to basic OpenGL calls or any alternative such as WebGL.

Associated with Vish is the Fiber Bundle Library and its Vish interface, known as Fiberbundle-Vish (Fish). It provides management for handling a wide class of data for scientific visualization.

How does it work?

VISH is about objects and interfaces with deferred implementations. VISH objects may specify input data ("slots") and which are created through a parameterized database. The implementation of the VISH interfaces (e.g. QVish) will then provide a GUI or equivalent input method for the respective parameter. The VObject itself is separated from these details and thus may be compiled independent from the parameter implementation. Using the same platform (hardware, compiler), pre-compiled VObjects may thus be shared in their binary form among various VISH implementations.

What can it do?

OpenGL rendering

Special children are derived from VRenderObject and may implement an OpenGL routine for 3D rendering (see The OpenGL Interface of Vish ).

class myRenderObject : public VRenderObject
{
public:
myRenderObject(const string&name, const VCreatorBase&VC)
: VRenderObject(name, VC)
{
addParam("size", 20);
}
// A simple OpenGL callback routine demonstrating how to render
// a parameterized object.
void render(VRenderContext & Context) const override
{
int size = 20;
// Here we check if the parameter is available.
// If not, we could also just continue with the internal default.
if (!getInputValue(size, "size", Context) )
return;
glBegin(GL_TRIANGLE);
glVertex2f(0,0);
glVertex2f(0,size);
glVertex2f(size,size);
glEnd();
}
};

Advanced parameter specification

If there are multiple implementations of an input parameter are available such that specification of its pure type is ambiguous, the parameter request may be refined further via VCreationPreferences. It is a list of desired properties, which are textual descriptions with weights. A VISH implementation may or may not provide a complete fulfillment of such a request. VISH will provide the best possible match.

Interaction notification

VISH provides routines to check a possible user interaction with an OpenGL render object or parts of it. Not every VISH implementation may provide this feature. However, the reference implementation QVish does.

Input parameter implementation

Input parameters are not limited to pre-defined native C++ types, but a parameter request may refer to any user-implemented type or structure. An implementation of an input parameter may be a VISH object itself. In particular, it may also be a VRenderObject and thereby implement a graphical input method for its associated input value.