Changeset 10522

Timestamp:

08/05/09 16:37:56 (4 years ago)

Author:

robert

Message:

Added support for volume tags with properties:

dragger="box" or dragger="trackball"

and

technique="light" or technique="isosurface" or technique="iso" or technique="mip"

and

tf="transferfunctionfile.tf"

i.e.

<volume dragger="box">CardiacCT</volume>
<volume tf="colour.tf">CardiacCT</volume>
<volume technique="isosurface">CardiacCT</volume>

Location:

OpenSceneGraph/trunk

Files:

• include/osgPresentation/SlideShowConstructor (modified) (4 diffs)
• src/osgPlugins/p3d/ReaderWriterP3D.cpp (modified) (3 diffs)
• src/osgPresentation/CMakeLists.txt (modified) (1 diff)
• src/osgPresentation/SlideShowConstructor.cpp (modified) (9 diffs)

OpenSceneGraph/trunk/include/osgPresentation/SlideShowConstructor

@@ -20 +20 @@
 #include <osg/Switch>
 #include <osg/AnimationPath>
+#include <osg/TransferFunction>
 #include <osg/ImageStream>
 #include <osgText/Text>
@@ -205 +206 @@
     };
 
+    struct VolumeData
+    {
+        enum ShadingModel
+        {
+            Standard,
+            Light,
+            Isosurface,
+            MaximumIntensityProjection
+        };
+
+        VolumeData():
+            shadingModel(Standard),
+            useTabbedDragger(false),
+            useTrackballDragger(false) {}
+
+        ShadingModel                            shadingModel;
+        osg::ref_ptr<osg::TransferFunction1D>   transferFunction;
+        bool                                    useTabbedDragger;
+        bool                                    useTrackballDragger;
+    };
+
+
     struct FontData
     {
@@ -317 +340 @@
     void addModel(const std::string& filename, const PositionData& positionData, const ModelData& modelData);
     
-    void addVolume(const std::string& filename, const PositionData& positionData);
+    void addVolume(const std::string& filename, const PositionData& positionData, const VolumeData& volumeData);
 
     osg::Group* takePresentation() { return _root.release(); }
@@ -334 +357 @@
     void setAutoSteppingActive(bool flag = true) { _autoSteppingActive = flag; }
     bool getAutoSteppingActive() const { return _autoSteppingActive; }
+
 
 protected:

OpenSceneGraph/trunk/src/osgPlugins/p3d/ReaderWriterP3D.cpp

@@ -121 +121 @@
     void parseModel(osgPresentation::SlideShowConstructor& constructor, osgDB::XmlNode*cur) const;
 
+    osg::TransferFunction1D* readTransferFunctionFile(const std::string& filename) const;
     void parseVolume(osgPresentation::SlideShowConstructor& constructor, osgDB::XmlNode*cur) const;
 
@@ -832 +833 @@
 }
 
-void ReaderWriterP3DXML::parseVolume(osgPresentation::SlideShowConstructor& constructor, osgDB::XmlNode*cur) const
+
+
+osg::TransferFunction1D* ReaderWriterP3DXML::readTransferFunctionFile(const std::string& filename) const
+{
+    std::string foundFile = osgDB::findDataFile(filename);
+    if (foundFile.empty())
+    {
+        std::cout<<"Error: could not find transfer function file : "<<filename<<std::endl;
+        return 0;
+    }
+
+    std::cout<<"Reading transfer function "<<filename<<std::endl;
+
+    osg::TransferFunction1D::ColorMap colorMap;
+    osgDB::ifstream fin(foundFile.c_str());
+    while(fin)
+    {
+        float value, red, green, blue, alpha;
+        fin >> value >> red >> green >> blue >> alpha;
+        if (fin)
+        {
+            std::cout<<"value = "<<value<<" ("<<red<<", "<<green<<", "<<blue<<", "<<alpha<<")"<<std::endl;
+            colorMap[value] = osg::Vec4(red,green,blue,alpha);
+        }
+    }
+
+    if (colorMap.empty())
+    {
+        std::cout<<"Error: No values read from transfer function file: "<<filename<<std::endl;
+        return 0;
+    }
+
+    osg::TransferFunction1D* tf = new osg::TransferFunction1D;
+    tf->assign(colorMap);
+
+    return tf;
+}
+
+
+void ReaderWriterP3DXML::parseVolume(osgPresentation::SlideShowConstructor& constructor, osgDB::XmlNode* cur) const
 {
 
@@ -838 +878 @@
     bool positionRead = getProperties(cur,positionData);
 
+    osgPresentation::SlideShowConstructor::VolumeData volumeData;
+
+    // check the rendering technique/shading model to use
+    std::string technique;
+    if (getProperty(cur, "technique", technique))
+    {
+        if      (technique=="standard") volumeData.shadingModel =  osgPresentation::SlideShowConstructor::VolumeData::Standard;
+        else if (technique=="mip") volumeData.shadingModel =  osgPresentation::SlideShowConstructor::VolumeData::MaximumIntensityProjection;
+        else if (technique=="isosurface" || technique=="iso" ) volumeData.shadingModel =  osgPresentation::SlideShowConstructor::VolumeData::Isosurface;
+        else if (technique=="light") volumeData.shadingModel =  osgPresentation::SlideShowConstructor::VolumeData::Light;
+    }
+
+    // check for any transfer function required
+    std::string transferFunctionFile;
+    if (getProperty(cur, "tf", transferFunctionFile))
+    {
+        volumeData.transferFunction = readTransferFunctionFile(transferFunctionFile);
+    }
+
+    // check for draggers required
+    std::string dragger;
+    if (getProperty(cur, "dragger", dragger))
+    {
+        if (dragger=="trackball")
+        {
+            volumeData.useTabbedDragger = false;
+            volumeData.useTrackballDragger = true;
+        }
+        else
+        {
+            volumeData.useTabbedDragger = true;
+            volumeData.useTrackballDragger = false;
+        }
+    }
+
     std::string filename = cur->contents;
-
     if (!filename.empty()) 
     {
         constructor.addVolume(filename,
-                             positionRead ? positionData : constructor.getModelPositionData());
+                             positionRead ? positionData : constructor.getModelPositionData(),
+                             volumeData);
     }
 }

OpenSceneGraph/trunk/src/osgPresentation/CMakeLists.txt

@@ -30 +30 @@
 LINK_INTERNAL(${LIB_NAME}
     osgViewer
+    osgManipulator
     osgVolume
     osgFX

OpenSceneGraph/trunk/src/osgPresentation/SlideShowConstructor.cpp

@@ -50 +50 @@
 #include <osgPresentation/AnimationMaterial>
 #include <osgPresentation/PickEventHandler>
+
+#include <osgManipulator/TabBoxDragger>
+#include <osgManipulator/TabPlaneTrackballDragger>
+#include <osgManipulator/TrackballDragger>
 
 using namespace osgPresentation;
@@ -1430 +1434 @@
 }
 
-
-void SlideShowConstructor::addVolume(const std::string& filename, const PositionData& positionData)
+class DraggerVolumeTileCallback : public osgManipulator::DraggerCallback
+{
+public:
+
+    DraggerVolumeTileCallback(osgVolume::VolumeTile* volume, osgVolume::Locator* locator):
+        _volume(volume),
+        _locator(locator) {}
+
+
+    virtual bool receive(const osgManipulator::MotionCommand& command);
+
+
+    osg::observer_ptr<osgVolume::VolumeTile>    _volume;
+    osg::ref_ptr<osgVolume::Locator>            _locator;
+
+    osg::Matrix _startMotionMatrix;
+
+    osg::Matrix _localToWorld;
+    osg::Matrix _worldToLocal;
+
+};
+
+bool DraggerVolumeTileCallback::receive(const osgManipulator::MotionCommand& command)
+{
+    if (!_locator) return false;
+
+    switch (command.getStage())
+    {
+        case osgManipulator::MotionCommand::START:
+        {
+            // Save the current matrix
+            _startMotionMatrix = _locator->getTransform();
+
+            // Get the LocalToWorld and WorldToLocal matrix for this node.
+            osg::NodePath nodePathToRoot;
+            osgManipulator::computeNodePathToRoot(*_volume,nodePathToRoot);
+            _localToWorld = _startMotionMatrix * osg::computeLocalToWorld(nodePathToRoot);
+            _worldToLocal = osg::Matrix::inverse(_localToWorld);
+
+            return true;
+        }
+        case osgManipulator::MotionCommand::MOVE:
+        {
+            // Transform the command's motion matrix into local motion matrix.
+            osg::Matrix localMotionMatrix = _localToWorld * command.getWorldToLocal()
+                                            * command.getMotionMatrix()
+                                            * command.getLocalToWorld() * _worldToLocal;
+
+            // Transform by the localMotionMatrix
+            _locator->setTransform(localMotionMatrix * _startMotionMatrix);
+
+            // osg::notify(osg::NOTICE)<<"New locator matrix "<<_locator->getTransform()<<std::endl;
+
+            return true;
+        }
+        case osgManipulator::MotionCommand::FINISH:
+        {
+            return true;
+        }
+        case osgManipulator::MotionCommand::NONE:
+        default:
+            return false;
+    }
+}
+
+void SlideShowConstructor::addVolume(const std::string& filename, const PositionData& positionData, const VolumeData& volumeData)
 {
     // osg::Object::DataVariance defaultMatrixDataVariance = osg::Object::DYNAMIC; // STATIC
@@ -1473 +1541 @@
     if (matrix)
     {
-        osgVolume::Locator* locator = new osgVolume::Locator(*matrix);
-        layer->setLocator(locator);
-        tile->setLocator(locator);
+        layer->setLocator(new osgVolume::Locator(*matrix));
+        tile->setLocator(new osgVolume::Locator(*matrix));
     }
 
@@ -1488 +1555 @@
     osgVolume::SampleDensityProperty* sd = new osgVolume::SampleDensityProperty(0.005);
     osgVolume::TransparencyProperty* tp = new osgVolume::TransparencyProperty(1.0);
+    osgVolume::TransferFunctionProperty* tfp = volumeData.transferFunction.valid() ? new osgVolume::TransferFunctionProperty(volumeData.transferFunction.get()) : 0;
 
     {
@@ -1495 +1563 @@
         cp->addProperty(sd);
         cp->addProperty(tp);
+        if (tfp) cp->addProperty(tfp);
 
         sp->addProperty(cp);
@@ -1506 +1575 @@
         cp->addProperty(tp);
         cp->addProperty(new osgVolume::LightingProperty);
+        if (tfp) cp->addProperty(tfp);
 
         sp->addProperty(cp);
@@ -1516 +1586 @@
         cp->addProperty(tp);
         cp->addProperty(new osgVolume::IsoSurfaceProperty(alphaFunc));
+        if (tfp) cp->addProperty(tfp);
 
         sp->addProperty(cp);
@@ -1527 +1598 @@
         cp->addProperty(tp);
         cp->addProperty(new osgVolume::MaximumIntensityProjectionProperty);
+        if (tfp) cp->addProperty(tfp);
 
         sp->addProperty(cp);
+    }
+
+    switch(volumeData.shadingModel)
+    {
+        case(VolumeData::Standard):                     sp->setActiveProperty(0); break;
+        case(VolumeData::Light):                        sp->setActiveProperty(1); break;
+        case(VolumeData::Isosurface):                   sp->setActiveProperty(2); break;
+        case(VolumeData::MaximumIntensityProjection):   sp->setActiveProperty(3); break;
     }
 
@@ -1535 +1615 @@
     tile->setEventCallback(new osgVolume::PropertyAdjustmentCallback());
 
+
+    osg::ref_ptr<osg::Node> model = volume.get();
+
+    if (volumeData.useTabbedDragger || volumeData.useTrackballDragger)
+    {
+        osg::ref_ptr<osg::Group> group = new osg::Group;
+
+        osg::ref_ptr<osgManipulator::Dragger> dragger;
+        if (volumeData.useTabbedDragger)
+            dragger = new osgManipulator::TabBoxDragger;
+        else
+            dragger = new osgManipulator::TrackballDragger();
+
+        dragger->setupDefaultGeometry();
+        dragger->setHandleEvents(true);
+        dragger->setActivationModKeyMask(osgGA::GUIEventAdapter::MODKEY_SHIFT);
+        dragger->addDraggerCallback(new DraggerVolumeTileCallback(tile.get(), tile->getLocator()));
+        dragger->setMatrix(osg::Matrix::translate(0.5,0.5,0.5)*tile->getLocator()->getTransform());
+
+
+        group->addChild(dragger.get());
+
+        //dragger->addChild(volume.get());
+
+        group->addChild(volume.get());
+
+        model = group.get();
+    }
+
+
+
     ModelData modelData;
-    addModel(volume.get(), positionData, modelData);
+    addModel(model.get(), positionData, modelData);
 }