image_pixel_view.cpp

Go to the documentation of this file.

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

#include "image_pixel_view.h"
#include "../controller/data_view_mediator.h"
#include "../datasets/image_pixel_dataset.h"

#include <Inventor/SbViewportRegion.h>
#include <Inventor/actions/SoGetMatrixAction.h>
#include <Inventor/nodes/SoCone.h>

namespace imedgine 
{ 
  ImagePixelView::ImagePixelView()
  : PixelView(IMAGE_PIXEL_VIEW)
  { 
    createSceneGraph();
  }
  
  //--------------------------------------------------
  
  ImagePixelView::ImagePixelView(ImagePixelView const& src)
  : PixelView(src)
  { 
    createSceneGraph();
  }   
  
  //--------------------------------------------------
  
  ImagePixelView::~ImagePixelView()
  {
  }
  
  //---------------------------------------------------
  
  view_pointer_type ImagePixelView::clone() const
  {
    return view_pointer_type(new ImagePixelView(*this));
  }
  
  //--------------------------------------------------

  dataset_key_type ImagePixelView::getDatasetKey() const
  {
    if (image_dataset_.get() != 0)
    {
      return(image_dataset_->getDatasetKey());
    }
    else
    {
      return(dataset_key_type());
    }
  }

  //-------------------------------------------------- 
  
  void ImagePixelView::createSceneGraph()
  {    
    View::createSceneGraph();  
    
    dynamic_camera_ = new SoOrthographicCamera();
    dynamic_sep_->addChild(dynamic_camera_);         
    
    //initialize slice  
    slice_separator_ = new SoSeparator();
    dynamic_sep_->addChild(slice_separator_);
    
    current_image_texture_ = new SoTexture2;       
    slice_separator_->addChild(current_image_texture_);  
    
    slice_dataset_material_ = new SoMaterial;  
    slice_dataset_material_->transparency = 0;  //fully opaque
    slice_separator_->addChild(slice_dataset_material_);  
      
    slice_plane_ = new SoCube;
    slice_separator_->addChild(slice_plane_);     
    
    //initialize crosshair   
    crosshair_sep_ = new SoSeparator();
    crosshair_coords_ = new SoCoordinate3;
    crosshair_sep_->addChild(crosshair_coords_);
    crosshair_color_ = new SoBaseColor();
    crosshair_color_->rgb = SbVec3f(0, 1, 0); //fluorescent green
    crosshair_sep_->addChild(crosshair_color_); 
    crosshair_lines_ = new SoLineSet();
    crosshair_sep_->addChild(crosshair_lines_);
    dynamic_sep_->addChild(crosshair_sep_);
  }    
  
  //--------------------------------------------------
  
  void ImagePixelView::setParent(QWidget* view_parent)
      throw(NullPointerException)   
  {
    PixelView::setParent(view_parent);
    
    if (view_parent_ == 0)
    {   
      throw(NullPointerException("ImagePixelView::setParent"));
    }
      
    render_area_.reset(new ImedgineImageViewer(this, view_parent_));
    
    //dynamic_camera_->viewAll(root_, render_area_->getViewportRegion());  
  
    render_area_->setSceneGraph(root_);    
  }
  
  //--------------------------------------------------
  
  void ImagePixelView::setDataset(dataset_pointer_type dataset)
      throw(NullPointerException, InvalidCastException)
  {
    if(dataset.get() == 0)
    {
      throw(NullPointerException("ImagePixelView::setDataset"));
    }
    
    ImagePixelDataset* image_pixel_dataset =
        dynamic_cast<ImagePixelDataset*>(dataset.get());

    if (image_pixel_dataset == 0)
    {
      throw(InvalidCastException("ImagePixelView::setDataset", 
            "dataset_pointer_type", "ImagePixelDataset*"));
    }
    
    image_pixel_dataset_pointer_type temp_dataset_copy(
        dataset, boost::detail::dynamic_cast_tag());
    image_dataset_ = temp_dataset_copy;
    
    View::setDataset(dataset);
    
    slice_plane_->depth = 0.0;
    float x_resolution = static_cast<float>(getSize()[X_DIMENSION]);
    float y_resolution = static_cast<float>(getSize()[Y_DIMENSION]);
    
    if (x_resolution > y_resolution)
    {
      slice_plane_->height = 2.0 *
          (y_resolution / x_resolution);  
      slice_plane_->width = 2.0; 
    }
    else
    {
      slice_plane_->height = 2.0;  
      slice_plane_->width = 2.0  *
          (x_resolution / y_resolution); 
    }       
  }
  
  //--------------------------------------------------
  
  dataset_position_type const& ImagePixelView::getSize() const
  {
    return(image_dataset_->getSize());
  }
  
  //---------------------------------------------------
  
  void ImagePixelView::updateView()
    throw(NullPointerException)
  {
    if (render_area_.get() == 0)
    {
      throw(NullPointerException("ImagePixelView::updateView"));
    } 
        
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return;
    }

    external_data_pointer_type image_data = image_dataset_->getData();
  
    current_image_texture_->image.setValue(
        SbVec2s(image_dataset_->getSize()[X_DIMENSION], 
                image_dataset_->getSize()[Y_DIMENSION]), 1, image_data);             
    
    render_area_->updateDatasetStatusInfo();      
    
    render_area_->show(); // maybe this is not needed here    
  }
  
  //--------------------------------------------------

  void ImagePixelView::onDataChangedEvent(dataset_attribute_type changed_attribute)
      throw(NullPointerException)
  {
    // reloading of the slice is handled by concrete slice views (XY, XZ or YZ)
    switch (changed_attribute)
    {
      case DATASET_ATTRIBUTE_INTENSITY :
      {
        updateView();
        break;
      }
      case DATASET_ATTRIBUTE_DATA :
      {
        updateView();
        break;
      }
      default :
      {
        break;
      }
    }
  }
  
  //--------------------------------------------------

  double ImagePixelView::getMinPixelValue() const
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return(0.0);
    }
    return(image_dataset_->getMinPixelValue());
  }

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

  double ImagePixelView::getMaxPixelValue() const
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return(0.0);
    }
    return(image_dataset_->getMaxPixelValue());
  }
  
  //---------------------------------------------------

  void ImagePixelView::setIntensity(double window, double level)
    throw(NullPointerException)   
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return;
    } 

    image_dataset_->setIntensity(window, level);

    notifyDataChangedEvent(DATASET_ATTRIBUTE_INTENSITY);
  }
  
  //--------------------------------------------------
    
  double ImagePixelView::getIntensityWindow() const
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return(0.0);
    }
    return(image_dataset_->getIntensityWindow());
  }
     
  //--------------------------------------------------

  double ImagePixelView::getIntensityLevel() const
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return(0.0);
    }
    return(image_dataset_->getIntensityLevel());
  }
  
  //---------------------------------------------------
  
  void ImagePixelView::setFocusPoint2D(index_type x, index_type y)
      throw(NullPointerException)
  {
    if ((image_dataset_.get() == 0) || (image_dataset_->isDataSet() == false))
    {
      return;
    }    

    //update focus point of dataset  
    try
    {
      image_dataset_->setFocusPointAt(X_DIMENSION, x);
    }
    catch (IndexOutOfBoundsException const&)
    {
      image_dataset_->setFocusPointAt(
          X_DIMENSION, image_dataset_->getSize()[X_DIMENSION] - 1);
    }
    try
    {
      image_dataset_->setFocusPointAt(Y_DIMENSION, y);
    }
    catch (IndexOutOfBoundsException const&)
    {
      image_dataset_->setFocusPointAt(
          Y_DIMENSION, image_dataset_->getSize()[Y_DIMENSION] - 1);
    }
  
    notifyDataChangedEvent(DATASET_ATTRIBUTE_FOCUS_POINT);
  }
  
  //---------------------------------------------------
  
  void ImagePixelView::drawCrosshair()
  {
    SbVec2s current_focus_point_2D;  
    SbVec2f crosshair_origin;
      
    //mapping from 3D to relevant 2D points
    current_focus_point_2D[X_DIMENSION] = image_dataset_->getFocusPoint()[X_DIMENSION];
    current_focus_point_2D[Y_DIMENSION] = image_dataset_->getFocusPoint()[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); 
  } 
}

---