SlicerWidget.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     6-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// SlicerWidget.h
///  simianUI

#include <qmainwindow.h>
#include <qpopupmenu.h>
#include "SlicerWidget.h"
#include "SlicerBase.h"
#include <qlayout.h>
#include <iostream>
#include <image/NrroImage.h>
#include <mathGutz.h>
#include <nrro/nrroUtil.h>

using namespace std;
using namespace gutz;

//////////////////////////////////////////////////////////////////////////
/// construction
//////////////////////////////////////////////////////////////////////////
SlicerWidget::SlicerWidget(QWidget *parent, char *name, WFlags f)
:QWidget(parent,name,f), 
 _sliceCanvas(0), 
 _sliceView(0),
 _slider(0),
 _number(0),
 _sliceImage(0),
 _axisCombo(0),
 _curAxis(X_AXIS),
 _curSlice(0),
 _vol(0),
 _filter(BoxKernel)
{
   _sliceCanvas = new QCanvas(200,200);
   _sliceCanvas->setDoubleBuffering(true);
   _sliceCanvas->setBackgroundColor(QColor(0,0,0));

   _sliceView = new SliceView(_sliceCanvas,this,"slice canvas");
   _sliceView->setVScrollBarMode(QScrollView::AlwaysOff);
   _sliceView->setHScrollBarMode(QScrollView::AlwaysOff);

   _slider = new QSlider(Qt::Horizontal,this,"slice number slider");

   _axisCombo = new QComboBox(FALSE, this, "axis chooser");

   /// slice image created on the canvas!!!
   _sliceImage = new NrroCanvasImg(_sliceCanvas);
   _sliceImage->show();

   conf();
}

//////////////////////////////////////////////////////////////////////////
/// destruction
//////////////////////////////////////////////////////////////////////////
SlicerWidget::~SlicerWidget()
{
   if(_sliceCanvas) delete _sliceCanvas;
   if(_sliceView) delete _sliceView;
   if(_slider) delete _slider;
   if(_axisCombo) delete _axisCombo;
   if(_sliceImage) delete _sliceImage;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// Slots
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

void SlicerWidget::resizeEvent(QResizeEvent *re)
{
   _sliceCanvas->resize(re->size().width(), re->size().height());
   /// update the image
   setSlice(_curSlice);
   _sliceCanvas->setAllChanged();
   _sliceCanvas->update();
   update();
}


//////////////////////////////////////////////////////////////////////////
/// Set Volume
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setVolume(VolumeSP vol)
{
   if(vol.isNull()) 
   {
      cerr << typeid(*this).name() 
         << "::setVolume(), attempting to set a null volume" << endl;
      return;
   }
   _vol = vol;
   setAxis(_curAxis);
   setSlice(_curSlice);
}

//////////////////////////////////////////////////////////////////////////
/// Set Axis
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setAxis(int axisId)
{

   if((X_AXIS != axisId)&&(Y_AXIS !=axisId)&&(Z_AXIS != axisId))
   {
      cerr << typeid(*this).name()
         << "::setAxis(), invalid axis id" << endl;
      return;
   }
   _curAxis = axisId;

   /// check if we have any setup
   if(_vol.isNull()) return;

   /// figure out what to do with the new axis
   /// first update the combo box
   _axisCombo->setCurrentItem(_curAxis);

   /// some error checking
   if(_vol->fields.getField(0) && _vol->fields.getField(0)->getNrro().isNull())
      return; 

   /// handle various volume configs, 3D or multi-channel 4D
   NrroSP n = _vol->fields.getField(0)->getNrro();
   int l = 0;
   if(_curAxis == X_AXIS)
   {
      if(n->dim() == 3)
      {
         l = n->dim(0)-1;
      }
      else
      {
         l = n->dim(1)-1;
      }
   }
   if(_curAxis == Y_AXIS)
   {
      if(n->dim() == 3)
      {
         l = n->dim(1)-1;
      }
      else
      {
         l = n->dim(2)-1;
      }
   }
   if(_curAxis == Z_AXIS)
   {
      if(n->dim() == 3)
      {
         l = n->dim(2)-1;
      }
      else
      {
         l = n->dim(3)-1;
      }
   }

   /// set the max value of the slider to the correct axis size
   _slider->setMaxValue(l);
   /// update the slice to reflect new axis
   setSlice(_curSlice);
}

//////////////////////////////////////////////////////////////////////////
/// Set Slice
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setSlice(int slicePos)
{
   if(_vol.isNull())
   {
      cerr << typeid(*this).name()
         << "::setSlice(), null volume" << endl;
      return;
   }

   /// no fields
   if(_vol->fields.size() == 0)
   {
      return;
   }
   
   NrroSP field = _vol->fields.getField(0)->getNrro();
   if(field.isNull())
   {
      cerr << typeid(*this).name()
         << "::setSlice(), null nrro field" << endl;
      return;
   }

   _curSlice = clamp(0,slicePos,_slider->maxValue());

   /// respect scalar and multi-channel volumes
   int inc = 0;
   if(field->dim() == 4) inc = 1;

   /// slice the data
   NrroSP slice = field->slice(_curAxis+inc,_curSlice);
   slice->setKind(Nrro::IMAGE);
   
   /// size of image we need, exactly the size of the viewport
   vec2i vsize(_sliceView->getWidth(), 
               _sliceView->getHeight());

   /// relative dimensions, min & max (0-1) base
   /// these depend on the aspect ratio and 
   /// position of the viewport relative to the image
   vec2f vmin(_sliceView->getPos());
   vec2f vmax = vmin + _sliceView->getAspect() * _sliceView->getZoom();
   _sliceImage->setNrro(reshapeNrroImageA(slice,vsize,vmin,vmax,_filter),field->getMinMax());

   _sliceCanvas->setAllChanged();
   _sliceCanvas->update();

   _slider->setValue(_curSlice);
}

//////////////////////////////////////////////////////////////////////////
/// Set Field ....
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setFieldOn(int fieldNum)
{

}

void SlicerWidget::setFieldOff(int fieldNum)
{

}

//////////////////////////////////////////////////////////////////////////
/// Set Pick Pos
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setPickPos(int xp, int yp)
{
   /// volume voxel positions
   int vx, vy, vz;

   if(_vol.isNull()) return;
   /// get the nrro
   NrroSP n = _vol->fields.getField(0)->getNrro();
   if(n.isNull()) return;

   /// handle multi-channel volumes correctly
   int inc = 0;
   if(n->dim() == 4) inc = 1;

   /// view space to world space
   float tx = _sliceView->getPos().x 
      + xp*(_sliceView->getAspect().x * _sliceView->getZoom())/_sliceView->getWidth();
   float ty = _sliceView->getPos().y 
      + yp*(_sliceView->getAspect().y *  _sliceView->getZoom())/_sliceView->getHeight();

   cerr << "pos = " << _sliceView->getPos() << endl;
   cerr << "aspect = " << _sliceView->getAspect() << endl;;
   cerr << "zoom = " << _sliceView->getZoom() << endl;
   cerr << "tx, ty " << tx << " " << ty << endl;

   if(_curAxis == X_AXIS)
   {
      vec2f aspect(vec2f_one);
      if(n->axisSize(1+inc) > n->axisSize(2+inc))
         aspect.y = n->axisSize(1+inc)/float(n->axisSize(2+inc));
      else
         aspect.x = n->axisSize(2+inc)/float(n->axisSize(1+inc));

      vx = _curSlice;
      vy =  static_cast<int>(tx * aspect.x * n->dim(1 + inc));
      vz =  static_cast<int>(ty * aspect.y * n->dim(2 + inc));
   }
   else if(_curAxis == Y_AXIS)
   {
      vec2f aspect(vec2f_one);
      if(n->axisSize(0+inc) > n->axisSize(2+inc))
         aspect.y = n->axisSize(0+inc)/float(n->axisSize(2+inc));
      else
         aspect.x = n->axisSize(2+inc)/float(n->axisSize(0+inc));
      vx =  static_cast<int>(tx * aspect.x * n->dim(0 + inc));
      vy = _curSlice;
      vz =  static_cast<int>(ty * aspect.y * n->dim(2 + inc));
   }
   else if(_curAxis == Z_AXIS)
   {
      vec2f aspect(vec2f_one);
      if(n->axisSize(0+inc) > n->axisSize(1+inc))
         aspect.y = n->axisSize(0+inc)/float(n->axisSize(1+inc));
      else
         aspect.x = n->axisSize(1+inc)/float(n->axisSize(0+inc));
      vx =  static_cast<int>(tx * aspect.x * n->dim(0 + inc));
      vy =  static_cast<int>(ty * aspect.y * n->dim(1 + inc));
      vz = _curSlice;
   }
      
   volPickPosChanged(vx,vy,vz);
}

//////////////////////////////////////////////////////////////////////////
/// Set Volume Pos
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setVolPos(int xp, int yp, int zp)
{
   if(_curAxis == X_AXIS)
   {
      setSlice(xp);
   }
   else if(_curAxis == Y_AXIS)
   {
      setSlice(yp);
   }
   else if(_curAxis == Z_AXIS)
   {
      setSlice(zp);
   }
}

//////////////////////////////////////////////////////////////////////////
/// Set Filter
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::setFilter(int f)
{
   switch(f){
      case SlicerBase::NEAREST:
         _filter = BoxKernel;
         break;
      case SlicerBase::BILIN:
         _filter = TentKernel;
         break;
      case SlicerBase::BICUBE:
         _filter = CatmulRomKernel;
         break;
      case SlicerBase::BSPLINE:
         _filter = BSplineKernel;
         break;
      default:
         cerr << "SlicerWidget::setFilter(), unknown filter" << endl;
   };

   setSlice(_curSlice);
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// Protected Members
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
/// configure
//////////////////////////////////////////////////////////////////////////
void SlicerWidget::conf()
{
   // Create a layout to position the widgets
   QHBoxLayout *topLayout = new QHBoxLayout( this, 5 );

   // Create a grid layout the slice view with relation
   // to the slider...
   // 2 rows, 1 column
   QGridLayout *grid = new QGridLayout(topLayout, 2,1);

   /// top widget
   grid->addWidget(_sliceView,0,0);
   /// connect the slice view to us
   connect(_sliceView,SIGNAL(pickPosChanged(int,int)), SLOT(setPickPos(int,int)));

   /// bottom widget
   // Create a grid layout for the slider and slice number
   // 2 rows, 2 columns
   QGridLayout *sliderGrid = new QGridLayout(grid,2,2);

   /// slice slider
   sliderGrid->addWidget(_slider,0,0);
   _slider->setValue(_curSlice);
   connect(_slider,SIGNAL(valueChanged(int)),SLOT(setSlice(int)));

   /// slice number
   QLCDNumber *num = new QLCDNumber(3,this,"slice number");
   num->setSegmentStyle(QLCDNumber::Flat);
   num->connect(_slider, SIGNAL(valueChanged(int)),SLOT(display(int)));
   sliderGrid->addWidget(num,0,1);

   /// axis combo box
   sliderGrid->addWidget(_axisCombo,1,0);
   _axisCombo->insertItem("X axis", X_AXIS);
   _axisCombo->insertItem("Y axis", Y_AXIS);
   _axisCombo->insertItem("Z axis", Z_AXIS);
   _axisCombo->setCurrentItem(_curAxis);
   connect(_axisCombo,SIGNAL(activated(int)),SLOT(setAxis(int)));

}

---

Send questions, comments, and bug reports to: