imedgine_image_viewer.cpp

Go to the documentation of this file.

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

#include "imedgine_image_viewer.h"
#include "image_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 <QPixmap>
#include <QImage>
#include <QDataStream>

#include <sstream>
#include <limits>

#include <stdio.h>

namespace imedgine 
{
  ImedgineImageViewer::ImedgineImageViewer(
      ImagePixelView* image_view, QWidget* parent, const char* name /*=NULL*/)
  : ImedgineViewer(parent, name),
    image_view_(image_view),
    view_mode_(DEFAULT_MODE),
    region_of_interest_(0),      
    double_click_check_time_(0.0),
    mouse_movement_scaling_factor_(1.0) 
  {
    QWidget* widget = this->buildWidget(this->getParentWidget());
    this->setBaseWidget(widget);
    this->setDecoration(false);  
      
    popup_button_sep_ = new SoSeparator;  
    image_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;
    image_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 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_);    

    region_of_interest_sep_ = new SoSeparator;
    image_view_->getDynamicSceneSeparator()->addChild(region_of_interest_sep_); 
       
    // calculate the mouse movement scaling factor depending on the minimum 
    // and maximum pixel value of the image
    mouse_movement_scaling_factor_ = (image_view_->getMaxPixelValue() -
            image_view_->getMinPixelValue()) / 1200.0;
  }
  
  //--------------------------------------------------  
  
  ImedgineImageViewer::~ImedgineImageViewer()
  {
#ifdef DEBUG
    std::cout << "Deleting ImedgineImageViewer" << std::endl;
#endif
  }

  //--------------------------------------------------   
  
  SbBool ImedgineImageViewer::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))
          {       
            
            //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(image_view_->getRenderArea()->getViewportRegion());
            rp.setPoint(pos);
            rp.apply(image_view_->getRenderArea()->getSceneGraph());                               
            
            //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);
              }
          
              image_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))
          {    
            
            //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 = image_view_->getIntensityWindow();
            new_window += x_difference * mouse_movement_scaling_factor_;
            if (new_window < 0)
            {
              new_window = 1;
            }
         
            double new_level = image_view_->getIntensityLevel();
            new_level += y_difference * mouse_movement_scaling_factor_;
      
            image_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
        {  
          return(false);     
        }     
        case SoMouseButtonEvent::BUTTON5: // wheel down
        {   
          return(false);
        }
        default:
        {}     
      }
    }
    return(ImedgineViewer::processSoEvent(ev));    
  }   

  //--------------------------------------------------   
  
  bool ImedgineImageViewer::convertCoordsFromScreenToTexture(
      SbVec2s const& screen_coords, SbVec2s& texture_coords)
  {
    SoRayPickAction rp(image_view_->getRenderArea()->getViewportRegion());
    rp.setPoint(screen_coords);
    rp.apply(image_view_->getRenderArea()->getSceneGraph());  
    
    SoPickedPoint* picked_point = rp.getPickedPoint(); 
          
    if (picked_point == 0)
    {
      //TODO: throw exception here   
      return(false);
    }
    
    float texture_xy_relation_factor =
        static_cast<float>(image_view_->getSize()[Y_DIMENSION]) /  
        static_cast<float>(image_view_->getSize()[X_DIMENSION]);    
    
    texture_coords[X_DIMENSION] = static_cast<short int>(
        (image_view_->getSize()[X_DIMENSION] *
        (picked_point->getPoint()[X_DIMENSION] + 0.5)) / 1.0);
          
    texture_coords[Y_DIMENSION] = static_cast<short int>(
        (image_view_->getSize()[Y_DIMENSION] * 
        (picked_point->getPoint()[Y_DIMENSION] + (texture_xy_relation_factor / 2.0))) /
        texture_xy_relation_factor);
    
    return (true);  
  }   
  
  //--------------------------------------------------   
  
  void ImedgineImageViewer::convertCoordsFromTextureToWorld(
      SbVec2s const& texture_coords, SbVec2f& space_coords)
  {
    float texture_xy_relation_factor = 
        static_cast<float>(image_view_->getSize()[Y_DIMENSION]) /  
        static_cast<float>(image_view_->getSize()[X_DIMENSION]);  
    
    space_coords[X_DIMENSION] = 
        (static_cast<float>(texture_coords[X_DIMENSION]) * 1.0 / 
        static_cast<float>(image_view_->getSize()[X_DIMENSION])) - 0.5;
  
    space_coords[Y_DIMENSION] = 
        (static_cast<float>(texture_coords[Y_DIMENSION]) * texture_xy_relation_factor / 
        static_cast<float>(image_view_->getSize()[Y_DIMENSION])) - 
        (texture_xy_relation_factor / 2.0);   
  }
  
  //--------------------------------------------------   
  
  void ImedgineImageViewer::updateDatasetStatusInfo()
  {
    std::ostringstream dataset_info_tmp;
    dataset_info_tmp << image_view_->getDatasetKey();
    
    dataset_status_info_text_->string = dataset_info_tmp.str().c_str();    
  }
  
  //--------------------------------------------------   
  
  SbVec3f ImedgineImageViewer::convertCoordsFromWorldToSpace(SbVec2s screen_coords)
      throw(NullPointerException)   
  {    
//     SbViewVolume view_volume = image_view_->getStaticCamera()->getViewVolume();
//  
//     SbVec2f normalized_screen_coords = SbVec2f(
//         static_cast<float>(screen_coords[X_DIMENSION]), 
//         static_cast<float>(screen_coords[Y_DIMENSION]));
//     
//     normalized_screen_coords.normalize();   
//     
//     // Find world space line along view direction through cursor
//     SbLine line;
//     view_volume.projectPointToLine(SbVec2f(
//         normalized_screen_coords[X_DIMENSION], 
//         normalized_screen_coords[Y_DIMENSION]), line);
// 
//     // Since you have an orthographic camera,
//     // the x and y values of any point on this
//     // line are the ones you want.
//     SbVec3f space_coords;
//     space_coords[X_DIMENSION] = line.getPosition()[X_DIMENSION];
//     space_coords[Y_DIMENSION] = line.getPosition()[Y_DIMENSION];
//     space_coords[Z_DIMENSION] = 0.1;  //TODO: value right?
//     return space_coords;
    
    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("ImedgineImageViewer::getWorldSpacePosition()"));   
    }
     
    return(ray_pick.getPickedPoint()->getPoint());        
  }    
      
} // namespace imedgine

---