imedgine_slice_viewer.cpp

Go to the documentation of this file.

//--------------------------------------------------
//---------------------------------------------------

#include "imedgine_slice_viewer.h"
#include "slice_pixel_view.h"
#include "../controller/controller.h"
#include "polyline_ROI.h"

#include <Inventor/actions/SoRayPickAction.h>
#include <Inventor/SoPickedPoint.h>
#include <Inventor/Qt/SoQtCursor.h>
#include <Inventor/nodes/SoTexture2.h>
#include <Inventor/nodes/SoBaseColor.h>
#include <Inventor/nodes/SoCone.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <Inventor/projectors/SbPlaneProjector.h>


#include <QPixmap>
#include <QImage>
#include <QDataStream>

#include <sstream>
#include <limits>

#include <stdio.h>

namespace imedgine 
{
  ImedgineSliceViewer::ImedgineSliceViewer(
      SlicePixelView* slice_view, QWidget* parent, const char* name /*=NULL*/)
  : ImedgineViewer(parent, name),
    slice_view_(slice_view),
    view_mode_(DEFAULT_MODE),
    region_of_interest_(0),      
    double_click_check_time_(0.0),
    is_hybrid_view_(false),
    mouse_movement_scaling_factor_(1.0),
    ignore_next_slice_slider_update_(false)
  {
    QWidget* widget = this->buildWidget(this->getParentWidget());
    this->setBaseWidget(widget);
    this->setDecoration(false);  
      
    popup_button_sep_ = new SoSeparator;  
    slice_view_->getStaticSceneSeparator()->addChild(popup_button_sep_);  
    
    SoTransform* popup_button_transform_ = new SoTransform;
    popup_button_transform_->translation = SbVec3f(-0.94, 0.93, 0.3);
    popup_button_sep_->addChild(popup_button_transform_);      
    
    SoTexture2* popup_button_texture = new SoTexture2;
    popup_button_sep_->addChild(popup_button_texture);
    //QPixmap temp_pixmap(":/icons/axial.png");
    QPixmap temp_pixmap(":/icons/document-open.png");
    
    unsigned char* converted_image = temp_pixmap.toImage().bits();  
    
/*    for (int index = 0; index <= temp_pixmap.toImage().numBytes(); index += 4)
    {
      unsigned char tmp;   
      
      tmp = converted_image[index];
      converted_image[index] = converted_image[index+3];
      converted_image[index+3] = tmp;       
    
      tmp = converted_image[index+1];
      converted_image[index+1] = converted_image[index+2];
      converted_image[index+2] = tmp;
    } */    
    
    std::cout << "Num bytes: " << temp_pixmap.toImage().numBytes() << std::endl;
    std::cout << "Num bytes per line: " << temp_pixmap.toImage().bytesPerLine() << std::endl;
    std::cout << "Height: " << temp_pixmap.toImage().size().height()  << std::endl;
    std::cout << "Width: " << temp_pixmap.toImage().size().width()  << std::endl; 
       
    popup_button_texture->image.setValue(
        SbVec2s(16,16), 
        4, converted_image);
      
    popup_button_ = new SoCube;  
    popup_button_->depth = 0;
    popup_button_->height = 0.1;  
    popup_button_->width = 0.1;  
    popup_button_sep_->addChild(popup_button_); 
    
    status_info_sep_ = new SoSeparator;
    slice_view_->getStaticSceneSeparator()->addChild(status_info_sep_); 
    SoBaseColor* status_info_color = new SoBaseColor;
    status_info_color->rgb = SbVec3f(0, 1, 0); // fluorescent green  
    status_info_sep_->addChild(status_info_color);
        
    //create slice status info  
    slice_status_info_transform_ = new SoTransform;
    slice_status_info_transform_->translation.setValue(0.97, 0.92, 0.3);  
    status_info_sep_->addChild(slice_status_info_transform_);  
    slice_status_info_text_ = new SoText2;
    slice_status_info_text_->justification = SoText2::RIGHT;  
    status_info_sep_->addChild(slice_status_info_text_); 
     
    //create dataset status info 
    dataset_status_info_transform_ = new SoTransform;
    dataset_status_info_transform_->translation.setValue(-1.8, 0, 0);  
    status_info_sep_->addChild(dataset_status_info_transform_);  
    dataset_status_info_text_ = new SoText2;
    dataset_status_info_text_->justification = SoText2::LEFT;  
    status_info_sep_->addChild(dataset_status_info_text_);   
    
    //create slice slider  
    slice_slider_sep_ = new SoSeparator;
    slice_view_->getStaticSceneSeparator()->addChild(slice_slider_sep_);    
    SoTransform* slice_slider_transform = new SoTransform;
    slice_slider_transform->scaleFactor.setValue(0.1, 0.1, 0.1);
    slice_slider_transform->translation.setValue(0, -0.90, 0.3);
    //slice_slider_transform->rotation = SbRotation(SbVec3f(0, 0, 1), M_PI/2);    
    slice_slider_sep_->addChild(slice_slider_transform);  
    slice_slider_dragger_ = new SoTranslate1Dragger;    
    slice_slider_sep_->addChild(slice_slider_dragger_);  
    SoMaterial* slice_slider_material = new SoMaterial;
    slice_slider_sep_->addChild(slice_slider_material);  
    slice_slider_material->diffuseColor.setValue(0, 1, 0); // fluorescent green
    slice_slider_material->transparency = 0.86;    
    SoCube* slice_slider_area = new SoCube;
    slice_slider_sep_->addChild(slice_slider_area);  
    slice_slider_area->depth = 0;
    slice_slider_area->width = 15;
    slice_slider_area->height = 0.15;         
    SoFieldSensor *sliceSliderSensor = 
        new SoFieldSensor(sliceSliderPositionChangedCB, this);
    sliceSliderSensor->attach(&slice_slider_dragger_->translation);      
        
    //create transparency slider  
    transparency_slider_switch_ = new SoSwitch;
    transparency_slider_switch_->whichChild = SO_SWITCH_NONE;  
    slice_view_->getStaticSceneSeparator()->addChild(transparency_slider_switch_);    
    transparency_slider_sep_ = new SoSeparator;
    transparency_slider_switch_->addChild(transparency_slider_sep_);     
    SoTransform* transparency_slider_transform = new SoTransform;
    transparency_slider_transform->scaleFactor.setValue(0.1, 0.1, 0.1);
    transparency_slider_transform->translation.setValue(-0.94, 0, 0.3);
    transparency_slider_transform->rotation = SbRotation(SbVec3f(0, 0, 1), M_PI/2);    
    transparency_slider_sep_->addChild(transparency_slider_transform);  
    transparency_slider_dragger_ = new SoTranslate1Dragger;    
    transparency_slider_sep_->addChild(transparency_slider_dragger_);  
    SoMaterial* transparency_slider_material = new SoMaterial;
    transparency_slider_sep_->addChild(transparency_slider_material);  
    transparency_slider_material->diffuseColor.setValue(0, 1, 0); // fluorescent green
    transparency_slider_material->transparency = 0.86;    
    SoCube* transparency_slider_area = new SoCube;
    transparency_slider_sep_->addChild(transparency_slider_area);  
    transparency_slider_area->depth = 0;
    transparency_slider_area->width = 15;
    transparency_slider_area->height = 0.15;         
    SoFieldSensor *transparencySliderSensor = new 
    SoFieldSensor(transparencySliderPositionChangedCB, this);
    transparencySliderSensor->attach(&transparency_slider_dragger_->translation);  

    region_of_interest_sep_ = new SoSeparator;
    slice_view_->getDynamicSceneSeparator()->addChild(region_of_interest_sep_);    
    
    mouse_movement_scaling_factor_ = (slice_view_->getMaxPixelValue() -
            slice_view_->getMinPixelValue()) / 1200.0;
  }
  
  //--------------------------------------------------  
  
  ImedgineSliceViewer::~ImedgineSliceViewer()
  {
#ifdef DEBUG
    std::cout << "Deleting ImedgineSliceViewer" << std::endl;
#endif
  }

  //--------------------------------------------------   
  
  SbBool ImedgineSliceViewer::processSoEvent(const SoEvent * const ev)
  { 
    const SoType type(ev->getTypeId());;
    
    //set DEFAULT cursor
    //FIXME: should not set for every event - but where else it is possible?  
    this->setComponentCursor(SoQtCursor::DEFAULT);   
    
    if (type.isDerivedFrom(SoLocation2Event::getClassTypeId())) 
    {   
      const SoLocation2Event * event = dynamic_cast<const SoLocation2Event *>(ev);  
      SbVec2s pos = ev->getPosition();   
      
      if (view_mode_ == ZOOM_IN_OUT_MODE)
      {  
        //set ZOOM cursor    
        this->setComponentCursor(SoQtCursor::getZoomCursor());         
        
        int diff = last_position_[Y_DIMENSION] - pos[Y_DIMENSION]; 
        
        SbViewVolume view_volume = this->getCamera()->getViewVolume();    
            
        //zoom in    
        if (diff < 0) 
        {     
          //restrict camera movement            
          if (view_volume.getHeight() < 0.3)
          {
            return(false);
          }          
          else if (diff == 0)
          {
            return(false);
          }                           
          else if (diff % 3 == 0)
          {     
            last_position_ = event->getPosition();       
            last_button_click_event_->setButton(SoMouseButtonEvent::BUTTON5);       
            return(ImedgineViewer::processSoEvent(last_button_click_event_.get()));
          }
        }
        //zoom out    
        else
        {   
          //restrict camera movement         
          if (view_volume.getHeight() > 5)
          {
            return(false);
          }              
          else if (diff == 0)
          {
            return(false);
          }                           
          else if (diff % 3 == 0)
          {     
            last_position_ = event->getPosition();         
            last_button_click_event_->setButton(SoMouseButtonEvent::BUTTON4);          
            return(ImedgineViewer::processSoEvent(last_button_click_event_.get()));
          }
        }      
      }
    }   
    
    if (type.isDerivedFrom(SoMouseButtonEvent::getClassTypeId())) 
    {
      const SoMouseButtonEvent * const event = dynamic_cast<const SoMouseButtonEvent *>(ev);
      const int button = event->getButton();
  
      const SbVec2s size(this->getGLSize());
      const SbVec2s pos(ev->getPosition());      
      
      switch (button) 
      {
        case SoMouseButtonEvent::BUTTON1:
        {                                         
          if (SoMouseButtonEvent::isButtonPressEvent(event, 
              SoMouseButtonEvent::BUTTON1))
          {       
            view_mode_ = FAST_SLICE_SCROLL_MODE;       
            
            //window/level movement
            left_mouse_button_press_location_ = pos;
            
            //Polyline ROI
            if (Controller::getInstance().getGuiInteractionMode() ==
                REGION_OF_INTEREST_POLY_LINE_MODE)
            {             
              if (region_of_interest_ == 0)
              {
                region_of_interest_ = new PolylineROI(region_of_interest_sep_);        
              }             
              
              try
              {           
                static_cast<PolylineROI*>(region_of_interest_)->addPoint(convertCoordsFromWorldToSpace(pos));  
                static_cast<PolylineROI*>(region_of_interest_)->drawROI();    
              }              
              catch (NullPointerException const&) 
              {
                //TODO: what should happen if the user clicks outside the texture?
                //at the moment this click is simply ignored                
              }  
                  
              return (false);       
            }        
           
            //Popup menu              
            SoRayPickAction rp(slice_view_->getRenderArea()->getViewportRegion());
            rp.setPoint(pos);
            rp.apply(slice_view_->getRenderArea()->getSceneGraph()); 

            if ((rp.getPickedPoint() != 0) && 
                (rp.getPickedPoint()->getPath()->getTail() == popup_button_))
            {         
              buildPopupMenu();                  
            
              std::auto_ptr<SoMouseButtonEvent> popup_button_click;       
              popup_button_click.reset(new SoMouseButtonEvent(*event));              
              popup_button_click->setButton(SoMouseButtonEvent::BUTTON2);          
              return(ImedgineViewer::processSoEvent(popup_button_click.get()));
            }   
                    
            //handle initial click on slider dragger      
            else if ((rp.getPickedPoint() != 0) && 
                     ((rp.getPickedPoint()->getPath()->getTail() == slice_slider_dragger_) ||
                      (rp.getPickedPoint()->getPath()->getTail() == transparency_slider_dragger_)))
            {
              this->setViewing(false); 
              view_mode_ = SLIDER_MOVE_MODE;             
              return(ImedgineViewer::processSoEvent(ev));
            }                               
            
            //double click for new crosshair position assignment     
            if (double_click_check_time_ == 0.0)
            {           
              double_click_check_time_ = ev->getTime();
              return(false);      
            }
               
            double_click_check_time_ = ev->getTime() - double_click_check_time_;     
          
            if (double_click_check_time_ < 0.5)  // 0.5 secs
            {
              SbVec2s texture_coords;     
              if (!convertCoordsFromScreenToTexture(pos, texture_coords))
              {
                return(false);
              }
          
              slice_view_->setFocusPoint2D(
                  texture_coords[X_DIMENSION], 
                  texture_coords[Y_DIMENSION]);
            
              //reset      
              double_click_check_time_ = 0.0;      
            }
            else
            {
              double_click_check_time_ = ev->getTime();
            }               
          }
          
          if (SoMouseButtonEvent::isButtonReleaseEvent(event, 
              SoMouseButtonEvent::BUTTON1))
          {    
            if (view_mode_ == SLIDER_MOVE_MODE)
            {
              view_mode_ = DEFAULT_MODE;      
              ImedgineViewer::processSoEvent(ev);
              this->setViewing(true);
              return (false);              
            }           
            
            //Window/level movement                  
            SbVec2s left_mouse_button_release_location = pos;
    
            int x_difference = left_mouse_button_release_location[X_DIMENSION] - 
                left_mouse_button_press_location_[X_DIMENSION];
            int y_difference = left_mouse_button_release_location[Y_DIMENSION] - 
                left_mouse_button_press_location_[Y_DIMENSION];
      
            //std::cout << "X Difference: " << x_difference << std::endl;
            //std::cout << "Y Difference: " << y_difference << std::endl;            
            
            double new_window = slice_view_->getIntensityWindow();
            new_window += x_difference * mouse_movement_scaling_factor_;
            if (new_window < 0)
            {
              new_window = 1;
            }
         
            double new_level = slice_view_->getIntensityLevel();
            new_level += y_difference * mouse_movement_scaling_factor_;
      
            slice_view_->setIntensity(new_window, new_level);
            
            view_mode_ = DEFAULT_MODE;
          }                         
           
          return(false);
        }      
        //right mouse button    
        case SoMouseButtonEvent::BUTTON2:
        { 
          //Polyline ROI
          if (Controller::getInstance().getGuiInteractionMode() == REGION_OF_INTEREST_POLY_LINE_MODE)
          {
            //auto-close polyline ROI
            static_cast<PolylineROI*>(region_of_interest_)->autoCloseROI();
            static_cast<PolylineROI*>(region_of_interest_)->drawROI();  
            
            Controller::getInstance().setGuiInteractionMode(STANDARD_MODE);         
            return (false);      
          }                                   
          
          last_position_ = event->getPosition();                      
          last_button_click_event_.reset(new SoMouseButtonEvent(*event));
               
          if (SoMouseButtonEvent::isButtonPressEvent(event, 
              SoMouseButtonEvent::BUTTON2))
          {
            view_mode_ = ZOOM_IN_OUT_MODE;          
          }
          else
          {
            view_mode_ = DEFAULT_MODE;   
          }                     
                      
          return(false);     
        }
        case SoMouseButtonEvent::BUTTON3:
        {
          return(ImedgineViewer::processSoEvent(event));
        }
        case SoMouseButtonEvent::BUTTON4: // wheel up
        {  
          int current_slide_index = slice_view_->getSliceIndex(); 
          
          if (view_mode_ == FAST_SLICE_SCROLL_MODE)
          {
            current_slide_index += 10;
          }
          else 
          {
            ++current_slide_index;
          }
          slice_view_->setSliceIndex(current_slide_index);
          return(false);     
        }     
        case SoMouseButtonEvent::BUTTON5: // wheel down
        {   
          int current_slide_index = slice_view_->getSliceIndex(); 
          
          if (view_mode_ == FAST_SLICE_SCROLL_MODE)
          {
            current_slide_index -= 10;
          }
          else
          {
            --current_slide_index;
          }
          
          if (current_slide_index < 0)
          {
            current_slide_index = 0;
          }
          slice_view_->setSliceIndex(current_slide_index);
          return(false);
        }
        default:
        {     
          return(ImedgineViewer::processSoEvent(ev));
        }     
      }
    }    

    return(ImedgineViewer::processSoEvent(ev));  
  }   

  //--------------------------------------------------   
  
  bool ImedgineSliceViewer::convertCoordsFromScreenToTexture(
      SbVec2s const& screen_coords, SbVec2s& texture_coords)
  {
    SoRayPickAction rp(slice_view_->getRenderArea()->getViewportRegion());
    rp.setPoint(screen_coords);
    rp.apply(slice_view_->getRenderArea()->getSceneGraph());  
    
    SoPickedPoint* picked_point = rp.getPickedPoint(); 
          
    if (picked_point == 0)
    {
      //TODO: throw exception here   
      return(false);
    }
    
    texture_coords[X_DIMENSION] = static_cast<short int>(
        (slice_view_->getSliceResolution()[X_DIMENSION] *
        (picked_point->getPoint()[X_DIMENSION] +
        (slice_view_->getSlicePlane()->width.getValue() / 2.0))) /
        slice_view_->getSlicePlane()->width.getValue());
          
    texture_coords[Y_DIMENSION] = static_cast<short int>(
        (slice_view_->getSliceResolution()[Y_DIMENSION] *
        (picked_point->getPoint()[Y_DIMENSION] + (slice_view_->getSlicePlane()->height.getValue() /
        2.0))) / slice_view_->getSlicePlane()->height.getValue());
    
    return (true);  
  }   
  
  //--------------------------------------------------   
  
  void ImedgineSliceViewer::convertCoordsFromTextureToWorld(
      SbVec2s const& texture_coords, SbVec2f& space_coords)
  {
    space_coords[X_DIMENSION] =
        (static_cast<float>(texture_coords[X_DIMENSION]) *
        slice_view_->getSlicePlane()->width.getValue() /
        static_cast<float>(slice_view_->getSliceResolution()[X_DIMENSION])) -
        (slice_view_->getSlicePlane()->width.getValue() / 2.0);

    space_coords[Y_DIMENSION] =
        (static_cast<float>(texture_coords[Y_DIMENSION]) *
        slice_view_->getSlicePlane()->height.getValue() /
        static_cast<float>(slice_view_->getSliceResolution()[Y_DIMENSION])) -
        (slice_view_->getSlicePlane()->height.getValue() / 2.0);
    
  }
  
  //--------------------------------------------------   
  
  void ImedgineSliceViewer::buildPopupMenu()
  {
    popup_menu = SoQtPopupMenu::createInstance();
    popup_menu->newMenu("SLICE MENU", SLICE_ROOT_MENU);
    popup_menu->setMenuTitle(SLICE_ROOT_MENU, "SLICE MENU");  
    
    popup_menu->newMenu("add_second_dataset_menu", SLICE_ADD_SECOND_DATASET_MENU);
    popup_menu->setMenuTitle(SLICE_ADD_SECOND_DATASET_MENU, "Add/remove second dataset");
    popup_menu->newRadioGroup(SLICE_ADD_SECOND_DATASET_GROUP);
      
    popup_menu->newMenu("lock_datasets_menu", LOCK_DATASETS_MENU);
    popup_menu->setMenuTitle(LOCK_DATASETS_MENU, "Lock datasets");
    //popup_menu->newRadioGroup(LOCK_DATASETS_GROUP);    
    
    std::vector<dataset_key_type> key_container;  
    Controller::getInstance().getLoadedDatasetKeys(key_container); 
    
    int add_dataset_key_menu_item_id = SLICE_ADD_SECOND_DATASET_MENU_ITEM; 
    int lock_datasets_menu_item_id = LOCK_DATASETS_MENU_ITEM;   
    
    for (std::vector<dataset_key_type>::const_iterator dataset_key_iter = 
         key_container.begin();
         dataset_key_iter != key_container.end(); ++dataset_key_iter)
    { 
      //dont't add the dataset to the popup menu if it is the dataset of THIS view   
      if (*dataset_key_iter != slice_view_->getDatasetKey())
      {    
        popup_menu->newMenuItem(dataset_key_iter->c_str(), add_dataset_key_menu_item_id); 
        popup_menu->addMenuItem(SLICE_ADD_SECOND_DATASET_MENU, add_dataset_key_menu_item_id);  
        popup_menu->addRadioGroupItem(SLICE_ADD_SECOND_DATASET_GROUP, add_dataset_key_menu_item_id);
        
        popup_menu->newMenuItem(dataset_key_iter->c_str(), lock_datasets_menu_item_id); 
        popup_menu->addMenuItem(LOCK_DATASETS_MENU, lock_datasets_menu_item_id);  
        //popup_menu->addRadioGroupItem(LOCK_DATASETS_GROUP, lock_datasets_menu_item_id);         
        
        //mark check boxes if second dataset is loaded    
        if (*dataset_key_iter == slice_view_->getSecondDatasetKey())
        {
          popup_menu->setMenuItemMarked(add_dataset_key_menu_item_id, true);        
        }   
            
        //mark check boxes if one or more datasets are locked    
        if (slice_view_->isLockedWithDataset(*dataset_key_iter)  == true)
        {
          popup_menu->setMenuItemMarked(lock_datasets_menu_item_id, true);        
        }           
        
        add_dataset_key_menu_item_id++;  
        lock_datasets_menu_item_id++;    
      }             
    }  
       
    popup_menu->addMenu(SLICE_ROOT_MENU, SLICE_ADD_SECOND_DATASET_MENU); 
    popup_menu->addMenu(SLICE_ROOT_MENU, LOCK_DATASETS_MENU);                
    popup_menu->addMenuSelectionCallback(ImedgineViewer::menuSelectionCallback, (void *) this);    
    
    this->prefmenu = popup_menu;

  }  
  
  //--------------------------------------------------   
  
  void ImedgineSliceViewer::menuSelection(int menu_item_id)
  {
    if (menu_item_id >= SLICE_ADD_SECOND_DATASET_MENU_ITEM && 
       menu_item_id < LOCK_DATASETS_MENU_ITEM)
    {
      std::vector<dataset_key_type> key_container;  
      Controller::getInstance().getLoadedDatasetKeys(key_container);
      
      if (is_hybrid_view_ == false)   
      {
        slice_view_->setSecondDataset(
            Controller::getInstance().getDataset(popup_menu->getMenuItemTitle(menu_item_id)));   
        
        is_hybrid_view_ = true;
        
        //show the transparency slider    
        transparency_slider_switch_->whichChild = SO_SWITCH_ALL;  ;            
      }
      else if (is_hybrid_view_ == true && 
               popup_menu->getMenuItemTitle(menu_item_id) != slice_view_->getSecondDatasetKey())
      {
        //unload the current second dataset    
        slice_view_->unsetSecondDataset(); 
         
        //load the new selected dataset    
        slice_view_->setSecondDataset(
            Controller::getInstance().getDataset(popup_menu->getMenuItemTitle(menu_item_id)));  
         
        is_hybrid_view_ = true;
        
        //show the transparency slider     
        transparency_slider_switch_->whichChild = SO_SWITCH_ALL;  ;                  
      }              
      else
      {
        slice_view_->unsetSecondDataset();
        
        is_hybrid_view_ = false; 
        
        //hide the transparency slider    
        transparency_slider_switch_->whichChild = SO_SWITCH_NONE;            
      }       
    }
    else if (menu_item_id >= LOCK_DATASETS_MENU_ITEM)
    {
      if (slice_view_->isLockedWithDataset(popup_menu->getMenuItemTitle(menu_item_id)) == false)
      {        
        slice_view_->lockWithDataset(popup_menu->getMenuItemTitle(menu_item_id));
      }
      else
      {
        slice_view_->unlockFromDataset(popup_menu->getMenuItemTitle(menu_item_id));      
      }       
    }     
  }
       
  //--------------------------------------------------   
  
  void ImedgineSliceViewer::updateSliceStatusInfo(
      index_type current_slice_index, index_type maximum_slice_index)
  {
    std::ostringstream slice_info_tmp;
    slice_info_tmp << "Slice: ";
    slice_info_tmp << current_slice_index;
    slice_info_tmp << "/";
    slice_info_tmp << maximum_slice_index;      
    slice_status_info_text_->string = slice_info_tmp.str().c_str();    
  }
  
  //--------------------------------------------------   
  
  void ImedgineSliceViewer::updateDatasetStatusInfo()
  {
    std::ostringstream dataset_info_tmp;
    dataset_info_tmp << slice_view_->getDatasetKey();
    
    if (slice_view_->getSecondDatasetKey() != "")
    {   
      dataset_info_tmp << "/";
      dataset_info_tmp << slice_view_->getSecondDatasetKey();      
    }
    
    dataset_status_info_text_->string = dataset_info_tmp.str().c_str();    
  }
   
  //--------------------------------------------------   
   
        
  void ImedgineSliceViewer::unsetHybridView()
  {     
     //hide the transparency slider    
    transparency_slider_switch_->whichChild = SO_SWITCH_NONE;
  }
  
  //--------------------------------------------------   
  
  SbVec3f ImedgineSliceViewer::convertCoordsFromWorldToSpace(SbVec2s screen_coords)
      throw(NullPointerException)   
  {    
    SoRayPickAction ray_pick(this->getViewportRegion());
    ray_pick.setPoint(screen_coords);
    ray_pick.apply(this->getSceneGraph()); 

    std::cout << "Picked point: " << ray_pick.getPickedPoint()->getPoint()[X_DIMENSION]
        << "/" << ray_pick.getPickedPoint()->getPoint()[Y_DIMENSION] << std::endl;
    
    if (ray_pick.getPickedPoint() == 0)  
    {
      throw(NullPointerException("ImedgineSliceViewer::getWorldSpacePosition()"));   
    }
     
    return(ray_pick.getPickedPoint()->getPoint());        
  }  
  
  //--------------------------------------------------     
  
  void ImedgineSliceViewer::updateSliceSliderPosition(index_type slice_index)
  {
    slice_slider_dragger_->translation.setValue(
        12.0 * static_cast<float>(slice_index) / 
        static_cast<float>(slice_view_->getNumSlices()) - 6, 0, 0);  
    
    std::cout << "Slider position: " << 12.0 * static_cast<float>(slice_index) / 
        static_cast<float>(slice_view_->getNumSlices()) - 6 << std::endl;
    
    ignore_next_slice_slider_update_ = true;  
  }    
  
  //--------------------------------------------------     
  
  void sliceSliderPositionChangedCB(void *data, SoSensor* sensor)
  {
    ImedgineSliceViewer* viewer = static_cast<ImedgineSliceViewer *>(data);  
        
    SoTranslate1Dragger* slider_dragger = viewer->getSliceSliderDragger();    
         
    //checks the boundaries of the slider  
    if (slider_dragger->translation.getValue()[0] > 6)
    {
      slider_dragger->translation.setValue(6, 0, 0);
      return;   
    }
    else if (slider_dragger->translation.getValue()[0] < -6)
    {
      slider_dragger->translation.setValue(-6, 0, 0);
      return;   
    }     
    
    if (viewer->getIgnoreNextSliceSliderUpdate() == true)
    {
      viewer->setIgnoreNextSliceSliderUpdate(false);
      return;   
    }         
          
    viewer->getSlicePixelView()->setSliceIndex(
        static_cast<int>((slider_dragger->translation.getValue()[0] + 6) * 
        viewer->getSlicePixelView()->getNumSlices() / 12));           
  }
   
  //--------------------------------------------------    
  
  void transparencySliderPositionChangedCB(void *data, SoSensor* sensor)
  {
    ImedgineSliceViewer* viewer = static_cast<ImedgineSliceViewer *>(data);  
        
    SoTranslate1Dragger* slider_dragger = viewer->getTransparencySliderDragger();  
    
    //checks the boundaries of the slider  
    if (slider_dragger->translation.getValue()[0] > 6)
    {
      slider_dragger->translation.setValue(6, 0, 0);
      return;   
    }
    else if (slider_dragger->translation.getValue()[0] < -6)
    {
      slider_dragger->translation.setValue(-6, 0, 0);
      return;   
    }
    
    float transparency_percent = 
        (slider_dragger->translation.getValue()[0] + 6) * 1.0 / 12.0;  

    if (transparency_percent > 1.0)
      transparency_percent = 1.0;      
    
    viewer->getSlicePixelView()->getSliceDatasetMaterial()->transparency = transparency_percent;
    
    viewer->getSlicePixelView()->getSliceSecondDatasetMaterial()->transparency = 
        1.0 - transparency_percent;   
  }    
}

---