xz_slice_view.cpp

Go to the documentation of this file.

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

#include "xz_slice_view.h"

namespace imedgine 
{
  XZSliceView::XZSliceView()
  : SlicePixelView(XZ_SLICE_VIEW)
  { 
  }
  
  //---------------------------------------------------
  
  XZSliceView::XZSliceView(view_type type)
  : SlicePixelView(type)
  { 
  }
  
  //---------------------------------------------------
  
  XZSliceView::XZSliceView(XZSliceView const& src)
  : SlicePixelView(src)
  {
  }    
  
  //---------------------------------------------------
  
  XZSliceView::~XZSliceView()
  {
#ifdef DEBUG
    std::cout << "Deleting XZ_SLICE_VIEW id: " << std::endl;
#endif
  }
  
  //---------------------------------------------------
  
  view_pointer_type XZSliceView::clone() const
  {
    return view_pointer_type(new XZSliceView(*this));
  }
  
  //---------------------------------------------------
    
  void XZSliceView::updateView()
      throw(NullPointerException)         
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }    
    
    external_data_pointer_type requested_slice;
    try
    {
      requested_slice = 
          volume_dataset_->getSliceXZ(volume_dataset_->getFocusPoint()[Y_DIMENSION]);
    }
    catch (IndexOutOfBoundsException const&)
    {
      requested_slice = 
          volume_dataset_->getSliceXZ(volume_dataset_->getSize()[Y_DIMENSION] - 1);  //take the last available slice
    }
  
    current_image_texture_->image.setValue(
        SbVec2s(volume_dataset_->getSize()[X_DIMENSION], 
                volume_dataset_->getSize()[Z_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_->getSliceXZ(volume_dataset_->getFocusPoint()[Y_DIMENSION]);
      }
      catch (IndexOutOfBoundsException const&) 
      { 
        //take the last available slice
        second_requested_slice = 
            second_volume_dataset_->getSliceXZ(second_volume_dataset_->getSize()[Y_DIMENSION] - 1);  
      } 
     
      current_second_image_texture_->image.setValue(
          SbVec2s(second_volume_dataset_->getSize()[X_DIMENSION], 
                  second_volume_dataset_->getSize()[Z_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()[Y_DIMENSION]);      
    
    SlicePixelView::updateView();   
  }
  
  //---------------------------------------------------
  
  void XZSliceView::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_[Y_DIMENSION] != volume_dataset_->getFocusPoint()[Y_DIMENSION])
        {
         updateView();  
        }
    
        current_focus_point_ = volume_dataset_->getFocusPoint();
        break;
      }
      default :
      {
        break;
      }
    }
    SlicePixelView::onDataChangedEvent(changed_attribute);  
  }
  
  //---------------------------------------------------
  
  void XZSliceView::setFocusPoint2D(index_type x, index_type z)
      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(Z_DIMENSION, z);
    }
    catch (IndexOutOfBoundsException const&)
    {
      volume_dataset_->setFocusPointAt(
          Z_DIMENSION, volume_dataset_->getSize()[Z_DIMENSION] - 1);
    }
    
    notifyDataChangedEvent(DATASET_ATTRIBUTE_FOCUS_POINT);   
  } 
   
  //---------------------------------------------------
  
  void XZSliceView::setSliceIndex(index_type slice_index)
      throw(NullPointerException)    
  {
    if ((volume_dataset_.get() == 0) || (volume_dataset_->isDataSet() == false))
    {
      return;
    }     
    
    try
    {
      volume_dataset_->setFocusPointAt(Y_DIMENSION, slice_index);
    }
    catch (IndexOutOfBoundsException const&)
    {
      volume_dataset_->setFocusPointAt(
          Y_DIMENSION, volume_dataset_->getSize()[Y_DIMENSION] - 1);
    }
  
    notifyDataChangedEvent(DATASET_ATTRIBUTE_FOCUS_POINT); 
  }
  
  //---------------------------------------------------
  
  index_type XZSliceView::getSliceIndex() const
  {
    return(current_focus_point_[Y_DIMENSION]);
  }
  
  //---------------------------------------------------
  
  index_type XZSliceView::getNumSlices() const
  {
    return(volume_dataset_->getSize()[Y_DIMENSION]);
  }   
  
  //---------------------------------------------------
  
  SbVec2s XZSliceView::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()[Z_DIMENSION]));
  }    
  
  //---------------------------------------------------
  
  SbVec2s XZSliceView::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()[Z_DIMENSION]));
  }    
  
  //---------------------------------------------------
  
  void XZSliceView::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_[Z_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); 
  }   
}

---