COVISE and OpenCOVER support

From Immersive Visualization Lab Wiki
Revision as of 13:57, 16 May 2007 by Jschulze (Talk | contribs)

Jump to: navigation, search

Contents

Lab hardware

We are using Suse Linux 10.0 on most of our lab machines. The names of the lab machines you have an account on are:

  • coutsound.ucsd.edu: AMD Opteron based file server and computer connected to dual-head setup next to projectors. Use this machine to compile and to change your password. Let me know when you change your password so that I can update it on the rest of the lab machines.
  • visualtest01.ucsd.edu: AMD Opteron based, drives lower half of c-wall
  • visualtest02.ucsd.edu: AMD Opteron based, drives upper half of c-wall
  • flint.ucsd.edu: Intel Pentium D based Dell in terminal room
  • chert.ucsd.edu: Intel Pentium D based Dell in terminal room
  • basalt.ucsd.edu: Intel Pentium D based Dell in terminal room
  • rubble.ucsd.edu: Intel Pentium D based Dell in terminal room

Due to the different computer hardware we use in the terminal room and the cave room, you should always compile your plugins on coutsound.

Account information

In order to cross login between lab machines without a password you will need to create a DSA key pair. To generate this you run the command 'ssh-keygen -t dsa' on any lab machine and use the default file names, and do not enter a pass phrase. This should generate two files in your ~/.ssh/ directory: id_dsa and id_dsa.pub. The last step is to copy the file id_dsa.pub to new file authorized_keys, or append the contents of id_dsa.pub to authorized_keys if it already exists.

General information about Covise modules

The entire Covise installation, including all plugins, is located at ~jschulze/covise/. Each user should have a link in their home directory named 'covise' which points to this directory. There should also be a link 'plugins' which points to the plugins directory. You should put all the plugins you write in this course into the directory: plugins/cse291/.

Other directories you might need throughout the project are:

  • covise/src/renderer/OpenCOVER/kernel/: core OpenCOVER functionality, especially coVRModuleSupport.cpp
  • covise/src/kernel/OpenVRUI/: OpenCOVER's user interface elements. useful documentation in doc/html subdirectory; browse by running Firefox on index.html
  • covise/src/renderer/OpenCOVER/osgcaveui/: special CaveUI functions, not required in class but useful

You compile your plugin with the 'make' command. This creates a library file in covise/amd64/lib/OpenCOVER/plugins/. Covise uses qmake, so the make file is being generated by the .pro file. The name of the plugin is determined by the project name in the .pro file in your plugin directory (first line, keyword TARGET). I defaulted TARGET to be p1<username> for project #1. It is important that the TARGET name be unique, or else you will overwrite somebody else's plugin. You can change the name of your source files or add additional source files (.cpp,.h) by listing them after the SOURCES tag in the .pro file.

You run OpenCOVER by typing 'opencover' anywhere at the command line. You quit opencover by hitting the 'q' key on the keyboard or ctrl-c in the shell window you started it from.

Good examples for plugins are plugins/Volume and plugins/PDBPlugin. Look at the code in these plugins to find out how to add menu items and how to do interaction. Note that there are two ways to do interaction: with pure OpenCOVER routines, or with OSGCaveUI. In this course we will try to use only OpenCOVER's own routines. Plugins do not get loaded by opencover before they are configured in the configuration file.

Covise configuration files

The configuration files are in the directory covise/config/. In class, the only files you need to look at are:

  • config.ucsd.xml: contains configuration information for all lab machines, except the c-wall machines
  • config.calitcwall.xml: contains configuration information for the c-wall machines only (visualtest01, visualtest02)

The configuration files are XML files which can be edited with any ASCII text editor (vi, emacs, nedit, gedit, ...). There are sections specific for certain machines. To load your plugin (e.g., p1jschulze) on one or more machines (e.g., chert and basalt), you need to add or modify a section to contain:

 <LOCAL host="chert,basalt">
   <COVERConfig>
     <Module value="p1jschulze" name="p1jschulze"/>
   </COVERConfig>
 </LOCAL>

Intersection testing

If you have wondered how you can find out if the wand pointer intersects your objects, here is a template routine for it. You need to pass it the beginning and end of a line you're intersecting with, in world coordinates. The line will be starting from the hand position and extend along the Y axis.

class IsectInfo     // this is an optional class to illustrate the return values of the accept() function
{
  public:
    bool       found;              ///< false: no intersection found
    osg::Vec3  point;              ///< intersection point
    osg::Vec3  normal;             ///< intersection normal
    osg::Geode geode;              ///< intersected Geode
};

void getObjectIntersection(Vec3& wPointerStart, Vec3& wPointerEnd, IsectInfo& isect)
{
  // Compute intersections of viewing ray with objects:
  osgUtil::IntersectVisitor iv;
  osg::ref_ptr<osg::LineSegment> testSegment = new LineSegment;
  testSegment->set(wStart, wEnd);
  iv.addLineSegment(testSegment.get());
  iv.setTraversalMask(2);
  
  // Traverse the whole scenegraph.
  // Non-Interactive objects must have been marked with setNodeMask(~2):
  _worldRoot->accept(iv);

  isect.found = false;
  if (iv.hits())
  {
    osgUtil::IntersectVisitor::HitList& hitList = iv.getHitList(testSegment.get());
    if(!hitList.empty())
    {
      isect.point  = hitList.front().getWorldIntersectPoint();
      isect.normal = hitList.front().getWorldIntersectNormal();
      isect.geode  = hitList.front()._geode;
    }
  }
}

Here is some code to get the pointer (=wand) position (pos1) and a point 1000 millimeters from it (pos2) along the pointer line:

   Vec3 pointerPos1Wld = cover->getPointerMat().getTrans();
   pointerPos1Wld.set(0.0, 1000.0, 0.0);
   Vec3 pointerPos2Wld = pointerPos1Wld * cover->getPointerMat();

Interaction handling

To register an interaction so that only your plugin uses the mouse pointer while a button on the wand is pressed, you want to use the TrackerButtonInteraction class. For sample usage see plugins/Volume. Here are the main calls you will need. Most of these functions go in the preFrame routine, unless otherwise noted:

  • Make sure you include at the top of your code:
     
          #include <OpenVRUI/coTrackerButtonInteraction.h>
        
  • In the constructor you want to create your interaction for button A, which is the left wand button:
          interaction = new coTrackerButtonInteraction(coInteraction::ButtonA,"MoveObject",coInteraction::Menu);
        
  • In the destructor you want to call:
          delete interaction;
        
  • To register your interaction and thus disable button A interaction in all other plugins call the following function. Make sure that to call this function before other modules can register the interaction. In particular, this might mean that you need to register the interaction before a mouse button is pressed, for instance by registering it when intersecting with the object to interact with.
          if(!interaction->registered)
          {
             coInteractionManager::the()->registerInteraction(interaction);
          }
        
  • To do something just once, after the interaction has just started:
          if(interaction->wasStarted())
          {
          }
        
  • To do something every frame while the interaction is running:
         if(interaction->isRunning())
         {
         }
        
  • To do something once at the end of the interaction:
         if(interaction->wasStopped())
         {
         }
        
  • To unregister the interaction and free button A for other plugins:
          if(interaction->registered && (interaction->getState()!=coInteraction::Active))
          {
             coInteractionManager::the()->unregisterInteraction(interaction);
          }
    
        

OSG Text

Make sure you #include <osgText/Text>. There is a good example for how osgText can be used in ~/covise/src/renderer/OpenCOVER/osgcaveui/Card.cpp. _highlight is the osg::Geode the text gets created for, createLabel() returns the Drawable with the text, _labelText is the text string, and osgText::readFontFile() reads the font.

OSG Images (Textures)

Again, the file ~/covise/src/renderer/OpenCOVER/osgcaveui/Card.cpp has a good example for this. _highlight is again the osg::Geode the image gets added to as a osg::Geometry. The osg::Geometry gets created in Card::createIcon(). The image itself is stored in _icon, which gets created at the top of Card::createGeometry(), but using osg::Image and osg::Texture2D.

Wall Clock Time

If you are going to animate anything, keep in mind that the rendering system runs anywhere between 1 and 100 frames per second, so you can't rely on the time between frames being anything you assume. Instead, you will want to know exactly how much time has passed since you last rendered something, i.e., you last preFrame() call. You should use cover->frameTime(), or better cover->frameDuration(); these return a double value with the number of seconds (at an accuracy of milli- or even microseconds) passed since the start of the program, or since the last preFrame(), respectively.

Backtrack all nodes up to top of scene graph

osg::NodePath path = getNodePath();
ref_ptr<osg::StateSet> state = new osg::StateSet;
for (osg::NodePath::iterator it = path.begin(); it != path.end(); ++it)
{
  if ((*it)->getStateSet())
  {
    state->merge((*it)->getStateSet());
  }
}


Taking a Screenshot

osg::camera allows you to take a screenshot at higher than physical display resolution. Here is an example from the email thread at http://openscenegraph.org/archiver/osg-users/2007-April/0054.html using wxWindows.

//save the old viewport:
osg::ref_ptr<osg::Viewport> AlterViewport = sceneView->getViewport();
osg::ref_ptr<osg::Image> shot = new osg::Image();
//shot->setPixelFormat(GL_RGB);

int w = 0; int h = 0;
GetClientSize(&w, &h);
float ratio = (float)w/(float)h;
w = 2500;
h = (int)((float)w/ratio);
//shot->scaleImage(w, h, 24);
shot->allocateImage(w, h, 24, GL_RGB, GL_UNSIGNED_BYTE);
osg::Node* subgraph = TheDocument->RootGroup.get();

osg::ref_ptr<osg::Camera> camera = new
osg::Camera(*(sceneView->getCamera()) );

// set view
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);

// set viewport
camera->setViewport(0,0,w,h);

// set the camera to render before the main camera.
camera->setRenderOrder(osg::Camera::PRE_RENDER);

// tell the camera to use OpenGL frame buffer object where supported.
camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);

camera->attach(osg::Camera::COLOR_BUFFER, shot.get());

// add subgraph to render
camera->addChild(subgraph);
//Need to mage it part of the scene :
sceneView->setSceneData(camera);

//Make it frame:
Update();
Refresh();

wxImage img;
img.Create(w, h);
img.SetData(shot->data());
shot.release();

wxImage i2 = img.Mirror(false);
i2.SaveFile(filename);
sceneView->setSceneData(subgraph);
sceneView->setViewport(AlterViewport.get() ); 

Return a ref_ptr from a function

Here is a safe way to return a ref_ptr type from a function.

osg::ref_ptr<osg::Group> makeGroup(...Some arguments..) 
{
  osg::ref_ptr<osg::MatrixTransform> mt=new MatrixTransform();
  // ...some operations...
  return mt.get();
} 

Also check out this link to learn more about how to use ref_ptr: http://donburns.net/OSG/Articles/RefPointers/RefPointers.html

Occlusion Culling in OpenSceneGraph

Occlusion culling removes objects which are hidden behind other objects in the culling stage so they never get rendered, thus resulting in a higher rendering rate. In covise/src/renderer/OpenCOVER/kernel/VRViewer.cpp, the SceneView is being created. By default CullingMode gets set like this:

  osg::CullStack::CullingMode cullingMode = cover->screens[i].sv->getCullingMode();
  cullingMode &= ~(osg::CullStack::SMALL_FEATURE_CULLING);
  cover->screens[i].sv->setCullingMode(cullingMode);

There isn't any way to automatically add occlusion culling to a scene, you'll need to insert convex planar occluders into your see. See the osgoccluder example for inspiration.

An alternative to occlusion culling is to use LOD (level of detail) nodes in the scene graph. This means that when you are farther away, less polygons get rendered.