volume_pixel_view.cpp

Go to the documentation of this file.

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

#include "volume_pixel_view.h"
#include "../controller/data_view_mediator.h"
#include "../datasets/volume_pixel_dataset.h"

namespace imedgine 
{ 
  VolumePixelView::VolumePixelView(view_type type)
  : PixelView(type),
    volume_dataset_(),
    second_volume_dataset_(),  
    current_focus_point_(3)
  { 
  }
         
  //---------------------------------------------------
  
  VolumePixelView::VolumePixelView(VolumePixelView const& src)
  : PixelView(src),
    volume_dataset_(),
    second_volume_dataset_(),  
    current_focus_point_(3)
  { 
  }
  
  //---------------------------------------------------
  
  VolumePixelView::~VolumePixelView()
  {
  }
  
  //---------------------------------------------------
  
  void VolumePixelView::setDataset(dataset_pointer_type dataset)
      throw(NullPointerException, InvalidCastException)
  {
    if(dataset.get() == 0)
    {
      throw(NullPointerException("VolumePixelView::setDataset"));
    }
    
    VolumePixelDataset* volume_pixel_dataset =
        dynamic_cast<VolumePixelDataset*>(dataset.get());

    if (volume_pixel_dataset == 0)
    {
      throw(InvalidCastException("VolumePixelView::setDataset", 
            "dataset_pointer_type", "VolumePixelDataset*"));
    }
    
    volume_pixel_dataset_pointer_type temp_dataset_copy(
        dataset, boost::detail::dynamic_cast_tag());
    volume_dataset_ = temp_dataset_copy;

    current_focus_point_[X_DIMENSION] = volume_dataset_->getFocusPoint()[X_DIMENSION];
    current_focus_point_[Y_DIMENSION] = volume_dataset_->getFocusPoint()[Y_DIMENSION];
    current_focus_point_[Z_DIMENSION] = volume_dataset_->getFocusPoint()[Z_DIMENSION]; 
    
    View::setDataset(dataset);
  }
  
  //---------------------------------------------------  
  
  void VolumePixelView::setSecondDataset(dataset_pointer_type second_dataset)
      throw(NullPointerException, InvalidCastException)    
  {
    if(second_dataset.get() == 0)
    {
      throw(NullPointerException("VolumePixelView::setDataset"));
    }
    
    VolumePixelDataset* second_volume_pixel_dataset =
        dynamic_cast<VolumePixelDataset*>(second_dataset.get());

    if (second_volume_pixel_dataset == 0)
    {
      throw(InvalidCastException("VolumePixelView::setDataset", 
            "dataset_pointer_type", "VolumePixelDataset*"));
    }
    
    volume_pixel_dataset_pointer_type temp_dataset_copy(
        second_dataset, boost::detail::dynamic_cast_tag());
    second_volume_dataset_ = temp_dataset_copy;
    
    bool current_focus_point_changed = false;
    
    // see to it that the current focus point lies within both datasets
    if (current_focus_point_[X_DIMENSION] >= second_volume_dataset_->getSize()[X_DIMENSION])
    {
      current_focus_point_[X_DIMENSION] = second_volume_dataset_->getFocusPoint()[X_DIMENSION];
      current_focus_point_changed = true;
    } 
    if (current_focus_point_[Y_DIMENSION] >= second_volume_dataset_->getSize()[Y_DIMENSION])
    {
      current_focus_point_[Y_DIMENSION] = second_volume_dataset_->getFocusPoint()[Y_DIMENSION];
      current_focus_point_changed = true;
    }
    if (current_focus_point_[Z_DIMENSION] >= second_volume_dataset_->getSize()[Z_DIMENSION])
    {
      current_focus_point_[Z_DIMENSION] = second_volume_dataset_->getFocusPoint()[Z_DIMENSION];
      current_focus_point_changed = true;
    }
    
    //second_volume_dataset_->setFocusPoint(current_focus_point_);
    
    // lock the datasets so that the dependant views of both datasets get
    // updated on changes of any of the two datasets
    //if (data_view_mediator_ != 0)
    //{
    //  data_view_mediator_->lockDatasets(dataset_key_, second_dataset_key_);
    //}
  }  
  
  //---------------------------------------------------
  
  void VolumePixelView::unsetSecondDataset()
  {
    if (second_volume_dataset_.get() != 0)
    {
      second_volume_dataset_.reset();
      updateView();
    }
  }
  
  //--------------------------------------------------

  dataset_key_type VolumePixelView::getDatasetKey() const
  {
    if (volume_dataset_.get() != 0)
    {
      return(volume_dataset_->getDatasetKey());
    }
    else
    {
      return(dataset_key_type());
    }
  }  
  
  //--------------------------------------------------

  dataset_key_type VolumePixelView::getSecondDatasetKey() const
  {
    if (second_volume_dataset_.get() != 0)
    {
      return(second_volume_dataset_->getDatasetKey());
    }
    else
    {
      return(dataset_key_type());
    }
  }
  
  //---------------------------------------------------
  
  void VolumePixelView::lockWithDataset(dataset_key_type dataset_key)
  {
    if (data_view_mediator_ != 0)
    {
      data_view_mediator_->lockDatasets(
          volume_dataset_->getDatasetKey(), dataset_key);
    }
  }
  
  //---------------------------------------------------
  
  void VolumePixelView::unlockFromDataset(dataset_key_type dataset_key)
  {
    if (data_view_mediator_ != 0)
    {
      data_view_mediator_->unlockDatasets(
          volume_dataset_->getDatasetKey(), dataset_key);
    }
  }
  
  //---------------------------------------------------
  
  bool VolumePixelView::isLockedWithDataset(dataset_key_type dataset_key)
  { 
    if (data_view_mediator_ != 0)
    {
      return(data_view_mediator_->areDatasetsLocked(
          volume_dataset_->getDatasetKey(), dataset_key));  
    }

    return(false);
  }
  
  //---------------------------------------------------
    
  volume_pixel_dataset_pointer_type VolumePixelView::getVolumeDataset()
  { 
    return(volume_dataset_); 
  }
  
  //---------------------------------------------------
  
  dataset_position_type const& VolumePixelView::getCurrentFocusPoint() const
  { 
    return(current_focus_point_);
  }
  
  //---------------------------------------------------

  void VolumePixelView::setIntensity(double window, double level)
    throw(NullPointerException)   
  {
    if ((volume_dataset_.get() == 0))
    {
      return;
    } 

    volume_dataset_->setIntensity(window, level);

    notifyDataChangedEvent(DATASET_ATTRIBUTE_INTENSITY);
  }
  
  //--------------------------------------------------
    
  double VolumePixelView::getIntensityWindow() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(0.0);
    }
    return(volume_dataset_->getIntensityWindow());
  }
     
  //--------------------------------------------------

  double VolumePixelView::getIntensityLevel() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(0.0);
    }
    return(volume_dataset_->getIntensityLevel());
  }
  
  //--------------------------------------------------
  
  void VolumePixelView::setTransformationMatrix(matrix_type const& matrix)
  {
    if (volume_dataset_.get() == 0)
    {
      return;
    }
    volume_dataset_->setTransformationMatrix(matrix);
    
    notifyDataChangedEvent(DATASET_ATTRIBUTE_TRANSFORMATION);
  }

  //--------------------------------------------------
  
  matrix_type VolumePixelView::getTransformationMatrix() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(matrix_type());
    }
    return(volume_dataset_->getTransformationMatrix());
  }

 //--------------------------------------------------
  
  offset_vector_type VolumePixelView::getOffsetVector() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(offset_vector_type());
    }
    return(volume_dataset_->getOffsetVector());
  }

  //--------------------------------------------------
  
  void VolumePixelView::setOffsetVector(offset_vector_type const& offset)
  {
    if (volume_dataset_.get() == 0)
    {
      return;
    }
    volume_dataset_->setOffsetVector(offset);
    
    notifyDataChangedEvent(DATASET_ATTRIBUTE_TRANSLATION);
  }

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

  unsigned char VolumePixelView::getNumBytesPerPixel() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(0);
    }
    return(volume_dataset_->getNumBytesPerPixel());
  }

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

  double VolumePixelView::getMinPixelValue() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(0.0);
    }
    return(volume_dataset_->getMinPixelValue());
  }

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

  double VolumePixelView::getMaxPixelValue() const
  {
    if (volume_dataset_.get() == 0)
    {
      return(0.0);
    }
    return(volume_dataset_->getMaxPixelValue());
  }
    
}

---