mitk: QmitkPointListModel.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision: 1.12 $
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "QmitkPointListModel.h"
00019 #include <itkCommand.h>
00020 #include "mitkInteractionConst.h"
00021 #include "mitkPointOperation.h"
00022 #include "mitkRenderingManager.h"
00023 #include <mitkPointSetInteractor.h>
00024 #include <mitkEvent.h>
00025 #include <mitkStateEvent.h>
00026 #include <mitkInteractionConst.h>
00027 
00028 
00029 QmitkPointListModel::QmitkPointListModel( mitk::DataNode* pointSetNode, int t, QObject* parent )
00030 :QAbstractListModel(parent),
00031 m_PointSetNode(NULL),
00032 m_PointSetModifiedObserverTag(0),
00033 m_PointSetDeletedObserverTag(0),
00034 m_TimeStep(t)
00035 {
00036   ObserveNewPointSet( pointSetNode );
00037 }
00038 
00039 Qt::ItemFlags QmitkPointListModel::flags(const QModelIndex& /*index*/) const
00040 {
00041   // no editing so far, return default (enabled, selectable)
00042   return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
00043 }
00044 
00045 QmitkPointListModel::~QmitkPointListModel()
00046 {
00047   this->ObserveNewPointSet( NULL );
00048 }
00049 
00050 void QmitkPointListModel::SetPointSetNode( mitk::DataNode* pointSetNode )
00051 {
00052   this->ObserveNewPointSet( pointSetNode );
00053   QAbstractListModel::reset();
00054   emit SignalUpdateSelection();
00055 }
00056 
00057 mitk::PointSet* QmitkPointListModel::GetPointSet() const
00058 {
00059   return this->CheckForPointSetInNode(m_PointSetNode);
00060 }
00061 
00062 void QmitkPointListModel::SetTimeStep(int t)
00063 {
00064   m_TimeStep = t;
00065   QAbstractListModel::reset();
00066   emit SignalUpdateSelection();
00067 }
00068 
00069 int QmitkPointListModel::GetTimeStep() const
00070 {
00071   return m_TimeStep;
00072 }
00073 
00074 void QmitkPointListModel::ObserveNewPointSet( mitk::DataNode* pointSetNode )
00075 {
00076   
00077   //remove old observers
00078   if (m_PointSetNode != NULL)
00079   {
00080     mitk::PointSet::Pointer oldPointSet = dynamic_cast<mitk::PointSet*>(m_PointSetNode->GetData());
00081     if (oldPointSet.IsNotNull())
00082     {
00083       oldPointSet->RemoveObserver(m_PointSetModifiedObserverTag);
00084       oldPointSet->RemoveObserver(m_PointSetDeletedObserverTag);
00085     }
00086   }
00087 
00088   //get the new pointset
00089   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(pointSetNode);
00090 
00091   m_PointSetNode = pointSetNode;
00092 
00093   if ( pointSet.IsNotNull())
00094   {
00095     // add new observer for modified if necessary
00096     itk::ReceptorMemberCommand<QmitkPointListModel>::Pointer modCommand = itk::ReceptorMemberCommand<QmitkPointListModel>::New();
00097     modCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetChanged );
00098     m_PointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand );
00099 
00100     // add new observer for detele if necessary
00101     itk::ReceptorMemberCommand<QmitkPointListModel>::Pointer delCommand = itk::ReceptorMemberCommand<QmitkPointListModel>::New();
00102     delCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetDeleted );
00103     m_PointSetDeletedObserverTag = pointSet->AddObserver( itk::DeleteEvent(), delCommand );
00104   }
00105   else
00106   {
00107     m_PointSetModifiedObserverTag = 0;
00108     m_PointSetDeletedObserverTag = 0;
00109   }
00110 }
00111 
00112 void QmitkPointListModel::OnPointSetChanged( const itk::EventObject &  /*e*/ )
00113 {
00114   QAbstractListModel::reset();
00115   emit SignalUpdateSelection();
00116 }
00117  
00118 void QmitkPointListModel::OnPointSetDeleted( const itk::EventObject &  /*e*/ )
00119 {
00120 //  m_PointSetNode = NULL;
00121   mitk::PointSet::Pointer ps = CheckForPointSetInNode(m_PointSetNode);
00122   if (ps)
00123   {
00124     ps->RemoveObserver(m_PointSetModifiedObserverTag);
00125     ps->RemoveObserver(m_PointSetDeletedObserverTag);
00126   }
00127 
00128   m_PointSetModifiedObserverTag = 0;
00129   m_PointSetDeletedObserverTag = 0;
00130   QAbstractListModel::reset();
00131 }
00132 
00133 int QmitkPointListModel::rowCount( const QModelIndex&  /*parent*/ ) const
00134 {
00135   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00136   if ( pointSet.IsNotNull() )
00137   {
00138     return pointSet->GetSize(m_TimeStep);
00139   }
00140   else
00141   {
00142     return 0;
00143   }
00144 }
00145 
00146 QVariant QmitkPointListModel::data(const QModelIndex& index, int role) const
00147 {
00148   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00149   
00150   if ( pointSet.IsNull() )
00151   {
00152     return QVariant();
00153   }
00154 
00155   if ( !index.isValid() )
00156   {
00157     return QVariant();
00158   }
00159 
00160   if ( index.row() >= pointSet->GetSize(m_TimeStep) )
00161   {
00162     return QVariant();
00163   }
00164 
00165   if (role == Qt::DisplayRole)
00166   {
00167     mitk::PointSet::PointsContainer::ElementIdentifier id;
00168     mitk::PointSet::PointType p;
00169     bool pointFound = this->GetPointForModelIndex(index, p, id);
00170     if (pointFound == false)
00171       return QVariant();
00172 
00173     QString s = QString("%0: (%1, %2, %3)")
00174       .arg( id, 3)
00175       .arg( p[0], 0, 'f', 3 )
00176       .arg( p[1], 0, 'f', 3 )
00177       .arg( p[2], 0, 'f', 3 );
00178     return QVariant(s);
00179   }
00180   else
00181   {
00182     return QVariant();
00183   }
00184 }
00185 
00186 QVariant QmitkPointListModel::headerData(int section, Qt::Orientation orientation, int role) const
00187 {
00188   if (role != Qt::DisplayRole)
00189   {
00190     return QVariant();
00191   }
00192 
00193   if (orientation == Qt::Horizontal)
00194   {
00195     return QString("Coordinates").arg(section);
00196   }
00197   else
00198   {
00199     return QString("Row %1").arg(section);
00200   }
00201 }
00202 
00203 bool QmitkPointListModel::GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p, 
00204                                                 mitk::PointSet::PointIdentifier& id) const
00205 {
00206   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00207   if (pointSet.IsNull())
00208     return false;
00209 
00210   if ((index.row() < 0) || (index.row() >= (int)pointSet->GetPointSet(m_TimeStep)->GetPoints()->Size()))
00211     return false;
00212 
00213   // get the nth. element, if it exists.
00214   // we can not use the index directly, because PointSet uses a map container, 
00215   // where the index is not necessarily the same as the key.
00216   // Therefore we have to count the elements
00217   mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStep)->GetPoints()->Begin();
00218   for (int i = 0; i < index.row(); ++i)
00219   {
00220     ++it;
00221   
00222     if (it == pointSet->GetPointSet(m_TimeStep)->GetPoints()->End())
00223       return false;
00224 
00225   }
00226 
00227   if (it != pointSet->GetPointSet(m_TimeStep)->GetPoints()->End()) // not at the end, 
00228   {
00229     p = it->Value();
00230     id = it->Index();
00231     return true;
00232   }
00233 
00234   return false;
00235 }
00236 
00237 bool QmitkPointListModel::GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index) const
00238 {
00239   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00240   if (pointSet.IsNull())
00241     return false;
00242 
00243   mitk::PointSet::PointsContainer::Pointer points = pointSet->GetPointSet(m_TimeStep)->GetPoints();
00244 
00245   if (points->IndexExists(id) == false)
00246     return false;
00247 
00248   unsigned int idx = 0;
00249   for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); ++it)
00250   {
00251     if (it->Index() == id) // we found the correct element
00252     {
00253       index = this->index(idx);
00254       return true;
00255     }
00256     
00257     idx++;
00258   }
00259 
00260   return false; // nothing found
00261 }
00262 
00263 void QmitkPointListModel::MoveSelectedPointUp()
00264 {
00265   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00266   if (pointSet.IsNull())
00267     return;
00268   
00269   mitk::PointSet::PointIdentifier selectedID;   
00270   selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
00271   mitk::PointSet::PointType point = pointSet->GetPoint(selectedID, m_TimeStep);
00272   mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStep);
00273   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP,tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
00274   pointSet->ExecuteOperation(doOp);
00275   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
00276 }
00277 
00278 void QmitkPointListModel::MoveSelectedPointDown()
00279 {
00280   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00281   if (pointSet.IsNull())
00282     return;
00283 
00284   mitk::PointSet::PointIdentifier selectedID; 
00285   selectedID = pointSet->SearchSelectedPoint(m_TimeStep);
00286   mitk::ScalarType tsInMS = pointSet->GetTimeSlicedGeometry()->TimeStepToMS(m_TimeStep);
00287   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true);
00288   pointSet->ExecuteOperation(doOp);
00289   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper
00290 }
00291 
00292 
00293 void QmitkPointListModel::RemoveSelectedPoint()
00294 {
00295   mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode);
00296   if (pointSet.IsNull())
00297     return;
00298 
00299   //get corresponding interactor to PointSet
00300   mitk::PointSetInteractor::Pointer interactor = dynamic_cast<mitk::PointSetInteractor*>(m_PointSetNode->GetInteractor());  
00301   if (interactor.IsNull())
00302   {
00303     if (m_PointSetNode->GetInteractor()==NULL && m_PointSetNode != NULL) //no Interactor set to node
00304     {
00305       interactor = mitk::PointSetInteractor::New("pointsetinteractor",m_PointSetNode);
00306       m_PointSetNode->SetInteractor(interactor);
00307     }
00308     else
00309     {
00310       MITK_WARN<<"Unexpected interactor found!\n";
00311       return;
00312     }
00313   }
00314 
00315 
00316   //send a DEL event to pointsetinteractor
00317   const mitk::Event* delEvent = new mitk::Event(NULL, mitk::Type_KeyPress, mitk::BS_NoButton, mitk::BS_NoButton, mitk::Key_Delete);
00318   mitk::StateEvent* delStateEvent = new mitk::StateEvent(mitk::EIDDELETE, delEvent);
00319   interactor->HandleEvent(delStateEvent);
00320   delete delEvent;
00321   delete delStateEvent;
00322 
00323   mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in PointSet/Mapper
00324 }
00325 
00326 mitk::PointSet* QmitkPointListModel::CheckForPointSetInNode(mitk::DataNode* node) const
00327 {
00328   if (node != NULL)
00329   {
00330     mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
00331     if (pointSet.IsNotNull())
00332       return pointSet;
00333   }
00334   return NULL;
00335 }
00336