xy_slice_view.cpp

Go to the documentation of this file.

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

#include "xy_slice_view.h"

namespace imedgine 
{
  XYSliceView::XYSliceView()
  : SlicePixelView(XY_SLICE_VIEW)
  { 
  }
  
  //---------------------------------------------------
  
  XYSliceView::XYSliceView(view_type type)
  : SlicePixelView(type)
  { 
  }
  
  //---------------------------------------------------
  
  XYSliceView::XYSliceView(XYSliceView const& src)
  : SlicePixelView(src)
  {
  }
  
  //---------------------------------------------------
  
  XYSliceView::~XYSliceView()
  {
#ifdef DEBUG
    std::cout << "Deleting XY_SLICE_VIEW" << std::endl;
#endif
  }
  
  //---------------------------------------------------
  
  view_pointer_type XYSliceView::clone() const
  {
    return view_pointer_type(new XYSliceView(*this));
  }
  
  //---------------------------------------------------
  
  void XYSliceView::updateView()
      throw(NullPointerException)      
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }

    external_data_pointer_type requested_slice;
    try
    {
      requested_slice = 
          volume_dataset_->getSliceXY(volume_dataset_->getFocusPoint()[Z_DIMENSION]);
    }
    catch (IndexOutOfBoundsException const&)
    {
      requested_slice = 
          volume_dataset_->getSliceXY(volume_dataset_->getSize()[Z_DIMENSION] - 1);
    }
  
    current_image_texture_->image.setValue(
        SbVec2s(volume_dataset_->getSize()[X_DIMENSION], 
                volume_dataset_->getSize()[Y_DIMENSION]), 1, requested_slice);
      
    if ((second_volume_dataset_.get() != 0) && (second_volume_dataset_->isDataSet() == true))
    {         
      external_data_pointer_type second_requested_slice;
      try
      {
        second_requested_slice = 
            second_volume_dataset_->getSliceXY(
            volume_dataset_->getFocusPoint()[Z_DIMENSION]);
      }
      catch (IndexOutOfBoundsException const&) 
      { 
        //take the last available slice
        second_requested_slice = 
            second_volume_dataset_->getSliceXY(
            second_volume_dataset_->getSize()[Z_DIMENSION] - 1);  
      } 
     
      current_second_image_texture_->image.setValue(
          SbVec2s(second_volume_dataset_->getSize()[X_DIMENSION], 
                  second_volume_dataset_->getSize()[Y_DIMENSION]), 1, 
          second_requested_slice);
      
      slice_dataset_material_->transparency = 0.5;
      slice_second_dataset_material_->transparency = 0.5;  
    }
    
    drawCrosshair();
        
    render_area_->updateSliceStatusInfo(getSliceIndex(),
                                        volume_dataset_->getSize()[Z_DIMENSION]);              
    
    SlicePixelView::updateView();
  }
  
  //---------------------------------------------------
  
  void XYSliceView::onDataChangedEvent(dataset_attribute_type changed_attribute)
      throw(NullPointerException)    
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }  
    
    switch (changed_attribute)
    {
      case DATASET_ATTRIBUTE_FOCUS_POINT :
      {
        if (current_focus_point_[Z_DIMENSION] != volume_dataset_->getFocusPoint()[Z_DIMENSION])
        {
         updateView();
        }     
        current_focus_point_ = volume_dataset_->getFocusPoint();
        break;
      }
      default :
      {
        break;
      }
    }
    
    SlicePixelView::onDataChangedEvent(changed_attribute);
  }
  
  //---------------------------------------------------
  
  void XYSliceView::setFocusPoint2D(index_type x, index_type y)
      throw(NullPointerException)
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }      
    
    //update focus point of dataset  
    try
    {
      volume_dataset_->setFocusPointAt(X_DIMENSION, x);
    }
    catch (IndexOutOfBoundsException const&)
    {
      volume_dataset_->setFocusPointAt(
          X_DIMENSION, volume_dataset_->getSize()[X_DIMENSION] - 1);
    }
    try
    {
      volume_dataset_->setFocusPointAt(Y_DIMENSION, y);
    }
    catch (IndexOutOfBoundsException const&)
    {
      volume_dataset_->setFocusPointAt(
          Y_DIMENSION, volume_dataset_->getSize()[Y_DIMENSION] - 1);
    }
      
    notifyDataChangedEvent(DATASET_ATTRIBUTE_FOCUS_POINT);
  }
  
  //---------------------------------------------------
  
  void XYSliceView::setSliceIndex(index_type slice_index)
      throw(NullPointerException)    
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }
    
    try
    {
      volume_dataset_->setFocusPointAt(Z_DIMENSION, slice_index);
    }
    catch (IndexOutOfBoundsException const&)
    {
      volume_dataset_->setFocusPointAt(
          Z_DIMENSION, volume_dataset_->getSize()[Z_DIMENSION] - 1);
    }
    
    notifyDataChangedEvent(DATASET_ATTRIBUTE_FOCUS_POINT);
  }
  
  //---------------------------------------------------
  
  index_type XYSliceView::getSliceIndex() const
  {
    return(current_focus_point_[Z_DIMENSION]);
  }
  
  //---------------------------------------------------
  
  index_type XYSliceView::getNumSlices() const
  {
    return(volume_dataset_->getSize()[Z_DIMENSION]);
  }  
  
  //---------------------------------------------------
  
  SbVec2s XYSliceView::getSliceResolution() const
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return(SbVec2s(0, 0)); 
    }
    return(SbVec2s(volume_dataset_->getSize()[X_DIMENSION], 
           volume_dataset_->getSize()[Y_DIMENSION]));
  }   
  
  //---------------------------------------------------
  
  SbVec2s XYSliceView::getSecondSliceResolution() const
  {  
    if ((second_volume_dataset_.get() == 0) ||
         (second_volume_dataset_->isDataSet() == false))
    {
      return(SbVec2s(0, 0)); 
    }
    return(SbVec2s(second_volume_dataset_->getSize()[X_DIMENSION],
           second_volume_dataset_->getSize()[Y_DIMENSION]));
  }    
  
  //---------------------------------------------------
  
  void XYSliceView::drawCrosshair()
  {
    SbVec2s current_focus_point_2D;  
    SbVec2f crosshair_origin;
      
    //mapping from 3D to relevant 2D points
    current_focus_point_2D[X_DIMENSION] = current_focus_point_[X_DIMENSION];
    current_focus_point_2D[Y_DIMENSION] = current_focus_point_[Y_DIMENSION];  
    
    render_area_->convertCoordsFromTextureToWorld(current_focus_point_2D, crosshair_origin);
    
    crosshair_coords_->point.set1Value(0, SbVec3f(-10, crosshair_origin[Y_DIMENSION], 0.01)); 
    crosshair_coords_->point.set1Value(1, SbVec3f(10, crosshair_origin[Y_DIMENSION], 0.01));
    crosshair_coords_->point.set1Value(2, SbVec3f(crosshair_origin[X_DIMENSION], -10, 0.01));
    crosshair_coords_->point.set1Value(3, SbVec3f(crosshair_origin[X_DIMENSION], 10, 0.01));
   
    crosshair_lines_->numVertices.setValue(4); 
  }    
}

---