mitk: QmitkSlicesInterpolator.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date: 2008-10-30 12:33:31 +0100 (Do, 30 Okt 2008) $
00006 Version:   $Revision: 15606 $
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 "QmitkSlicesInterpolator.h"
00019 
00020 #include "QmitkStdMultiWidget.h"
00021 #include "QmitkSelectableGLWidget.h"
00022 
00023 #include "mitkToolManager.h"
00024 #include "mitkDataNodeFactory.h"
00025 #include "mitkLevelWindowProperty.h"
00026 #include "mitkColorProperty.h"
00027 #include "mitkProperties.h"
00028 #include "mitkRenderingManager.h"
00029 #include "mitkOverwriteSliceImageFilter.h"
00030 #include "mitkProgressBar.h"
00031 #include "mitkGlobalInteraction.h"
00032 #include "mitkOperationEvent.h"
00033 #include "mitkUndoController.h"
00034 #include "mitkInteractionConst.h"
00035 #include "mitkApplyDiffImageOperation.h"
00036 #include "mitkDiffImageApplier.h"
00037 #include "mitkOperationEvent.h"
00038 #include "mitkSegTool2D.h"
00039 #include "mitkCoreObjectFactory.h"
00040 
00041 #include <itkCommand.h>
00042 
00043 #include <QCheckBox>
00044 #include <QPushButton>
00045 #include <QMenu>
00046 #include <QCursor>
00047 #include <QHBoxLayout>
00048 
00049 #define ROUND(a)     ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
00050 
00051 const std::map<QAction*, unsigned int> QmitkSlicesInterpolator::createActionToSliceDimension()
00052 {
00053   std::map<QAction*, unsigned int> actionToSliceDimension;
00054   actionToSliceDimension[new QAction("Transversal (red window)", 0)] = 2;
00055   actionToSliceDimension[new QAction("Sagittal (green window)", 0)] = 0;
00056   actionToSliceDimension[new QAction("Coronal (blue window)", 0)] = 1;
00057   return actionToSliceDimension;
00058 }
00059 
00060 
00061 QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char*  /*name*/)
00062 :QWidget(parent),
00063  ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
00064  m_Interpolator( mitk::SegmentationInterpolationController::New() ),
00065  m_MultiWidget(NULL),
00066  m_ToolManager(NULL),
00067  m_Initialized(false),
00068  m_LastSliceDimension(2),
00069  m_LastSliceIndex(0),
00070  m_InterpolationEnabled(false)
00071 {
00072   QHBoxLayout* layout = new QHBoxLayout(this);
00073 
00074   m_BtnAcceptInterpolation = new QPushButton("Accept...", this);
00075   m_BtnAcceptInterpolation->setEnabled( false );
00076   connect( m_BtnAcceptInterpolation, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()) );
00077   layout->addWidget( m_BtnAcceptInterpolation, 1 );
00078 
00079   m_BtnAcceptAllInterpolations = new QPushButton("... for all slices", this);
00080   m_BtnAcceptAllInterpolations->setEnabled( false );
00081   connect( m_BtnAcceptAllInterpolations, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()) );
00082   layout->addWidget( m_BtnAcceptAllInterpolations );
00083 
00084   itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
00085   command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged );
00086   InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver( itk::ModifiedEvent(), command );
00087 
00088   // feedback node and its visualization properties
00089   m_FeedbackNode = mitk::DataNode::New();
00090   mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_FeedbackNode );
00091 
00092   m_FeedbackNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
00093   m_FeedbackNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
00094   m_FeedbackNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 1.0, 1.0) );
00095   m_FeedbackNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
00096   m_FeedbackNode->SetProperty( "layer", mitk::IntProperty::New( 20 ) );
00097   m_FeedbackNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
00098   m_FeedbackNode->SetProperty( "name", mitk::StringProperty::New("Interpolation feedback") );
00099   m_FeedbackNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
00100   m_FeedbackNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
00101 
00102   QWidget::setContentsMargins(0, 0, 0, 0);
00103   if ( QWidget::layout() != NULL )
00104   {
00105     QWidget::layout()->setContentsMargins(0, 0, 0, 0);
00106   }
00107 }
00108 
00109 void QmitkSlicesInterpolator::SetDataStorage( mitk::DataStorage& storage )
00110 {
00111   m_DataStorage = &storage;
00112 }
00113 
00114 mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
00115 {
00116   if ( m_DataStorage.IsNotNull() )
00117   {
00118     return m_DataStorage;
00119   }
00120   else
00121   {
00122     return NULL;
00123   }
00124 }
00125 
00126 
00127 void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, QmitkStdMultiWidget* multiWidget)
00128 {
00129   if (m_Initialized)
00130   {
00131     // remove old observers
00132     if (m_ToolManager)
00133     {
00134       m_ToolManager->WorkingDataChanged 
00135         -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
00136 
00137       m_ToolManager->ReferenceDataChanged 
00138         -= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
00139     }
00140 
00141     if (m_MultiWidget)
00142     {
00143       disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
00144       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
00145       slicer->RemoveObserver( TSliceObserverTag );
00146       slicer->RemoveObserver( TTimeObserverTag );
00147       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
00148       slicer->RemoveObserver( SSliceObserverTag );
00149       slicer->RemoveObserver( STimeObserverTag );
00150       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
00151       slicer->RemoveObserver( FSliceObserverTag );
00152       slicer->RemoveObserver( FTimeObserverTag );
00153     }
00154 
00155     //return;
00156   }
00157 
00158   m_MultiWidget = multiWidget;
00159 
00160   connect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
00161 
00162   m_ToolManager = toolManager;
00163 
00164   if (m_ToolManager)
00165   {
00166     // set enabled only if a segmentation is selected
00167     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
00168     QWidget::setEnabled( node != NULL );
00169 
00170     // react whenever the set of selected segmentation changes
00171     m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
00172     m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
00173 
00174     // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
00175     if (m_MultiWidget)
00176     {
00177       mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
00178       m_TimeStep.resize(3);
00179       m_TimeStep[2] = slicer->GetTime()->GetPos();
00180       {
00181       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
00182       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnTransversalTimeChanged );
00183       TTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
00184       }
00185 
00186       {
00187       itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
00188       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnTransversalSliceChanged );
00189       TSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
00190       }
00191 
00192       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
00193       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
00194       m_TimeStep[0] = slicer->GetTime()->GetPos();
00195       {
00196       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
00197       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalTimeChanged );
00198       STimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
00199       }
00200 
00201       {
00202       itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
00203       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalSliceChanged );
00204       SSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
00205       }
00206 
00207       // connect to the steppers of the three multi widget widgets. after each change, call the interpolator
00208       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
00209       m_TimeStep[1] = slicer->GetTime()->GetPos();
00210       {
00211       itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
00212       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalTimeChanged );
00213       FTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
00214       }
00215 
00216       {
00217       itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
00218       command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalSliceChanged );
00219       FSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
00220       }
00221     }
00222   }
00223 
00224   m_Initialized = true;
00225 }
00226 
00227 QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
00228 { 
00229   if (m_MultiWidget)
00230   {
00231     mitk::SliceNavigationController* slicer;
00232     if(m_MultiWidget->mitkWidget1 != NULL)
00233     {
00234       slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
00235       slicer->RemoveObserver( TSliceObserverTag );
00236       slicer->RemoveObserver( TTimeObserverTag );
00237     }
00238     if(m_MultiWidget->mitkWidget2 != NULL)
00239     {
00240       slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
00241       slicer->RemoveObserver( SSliceObserverTag );
00242       slicer->RemoveObserver( STimeObserverTag );
00243     }
00244     if(m_MultiWidget->mitkWidget3 != NULL)
00245     {
00246       slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
00247       slicer->RemoveObserver( FSliceObserverTag );
00248       slicer->RemoveObserver( FTimeObserverTag );
00249     }
00250   }
00251 }
00252 
00253 void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
00254 {
00255   OnInterpolationActivated( m_InterpolationEnabled ); // re-initialize if needed
00256 }
00257 
00258 void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
00259 {
00260   OnInterpolationActivated( m_InterpolationEnabled ); // re-initialize if needed
00261 }
00262 
00263 
00264 void QmitkSlicesInterpolator::OnTransversalTimeChanged(itk::Object* sender, const itk::EventObject& e)
00265 {
00266   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
00267   m_TimeStep[2] = event.GetPos();
00268 
00269   if (m_LastSliceDimension == 2)
00270   {
00271     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
00272     if (snc) snc->SendSlice(); // will trigger a new interpolation
00273     //mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate(); // done in SendSlice
00274   }
00275 }
00276 
00277 void QmitkSlicesInterpolator::OnSagittalTimeChanged(itk::Object* sender, const itk::EventObject& e)
00278 {
00279   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
00280   m_TimeStep[0] = event.GetPos();
00281 
00282   if (m_LastSliceDimension == 0)
00283   {
00284     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
00285     if (snc) snc->SendSlice(); // will trigger a new interpolation
00286     //mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate(); // done in SendSlice
00287   }
00288 }
00289 
00290 void QmitkSlicesInterpolator::OnFrontalTimeChanged(itk::Object* sender, const itk::EventObject& e)
00291 {
00292   const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
00293   m_TimeStep[1] = event.GetPos();
00294 
00295   if (m_LastSliceDimension == 1)
00296   {
00297     mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
00298     if (snc) snc->SendSlice(); // will trigger a new interpolation
00299     //mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate(); // done in SendSlice
00300   }
00301 }
00302 
00303 
00304 void QmitkSlicesInterpolator::OnTransversalSliceChanged(const itk::EventObject& e)
00305 {
00306   if ( TranslateAndInterpolateChangedSlice( e, 2 ) )
00307   {
00308     if (m_MultiWidget)
00309     {
00310       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate();
00311     }
00312   }
00313 }
00314 
00315 void QmitkSlicesInterpolator::OnSagittalSliceChanged(const itk::EventObject& e)
00316 {
00317   if ( TranslateAndInterpolateChangedSlice( e, 0 ) )
00318   {
00319     if (m_MultiWidget)
00320     {
00321       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate();
00322     }
00323   }
00324 }
00325 
00326 void QmitkSlicesInterpolator::OnFrontalSliceChanged(const itk::EventObject& e)
00327 {
00328   if ( TranslateAndInterpolateChangedSlice( e, 1 ) )
00329   {
00330     if (m_MultiWidget)
00331     {
00332       mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate();
00333     }
00334   }
00335 }
00336 
00337 bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, unsigned int windowID)
00338 {
00339   if (!m_InterpolationEnabled) return false;
00340 
00341   try
00342   {
00343     const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
00344 
00345     mitk::TimeSlicedGeometry* tsg = event.GetTimeSlicedGeometry();
00346     if (tsg && m_TimeStep.size() > windowID)
00347     {
00348       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometry3D(m_TimeStep[windowID]));
00349       if (slicedGeometry)
00350       {
00351         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
00352         Interpolate( plane, m_TimeStep[windowID] );
00353         return true;
00354       }    
00355     }
00356   }
00357   catch(std::bad_cast)
00358   {
00359     return false; // so what
00360   }
00361 
00362   return false;
00363 }
00364 
00365 void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep )
00366 {
00367   if (m_ToolManager)
00368   {
00369     mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
00370     if (node)
00371     {
00372       m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
00373       if (m_Segmentation)
00374       {
00375         int clickedSliceDimension(-1);
00376         int clickedSliceIndex(-1);
00377 
00378         // calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
00379         mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
00380         mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, timeStep );
00381 
00382         m_FeedbackNode->SetData( interpolation );
00383         m_LastSliceDimension = clickedSliceDimension;
00384         m_LastSliceIndex = clickedSliceIndex;
00385       }
00386     }
00387   }
00388 }
00389 
00390 void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
00391 {
00392   if (m_Segmentation && m_FeedbackNode->GetData())
00393   {
00394     //making interpolation separately undoable
00395     mitk::UndoStackItem::IncCurrObjectEventId();
00396     mitk::UndoStackItem::IncCurrGroupEventId();
00397     mitk::UndoStackItem::ExecuteIncrement();
00398 
00399     mitk::OverwriteSliceImageFilter::Pointer slicewriter = mitk::OverwriteSliceImageFilter::New();
00400     slicewriter->SetInput( m_Segmentation );
00401     slicewriter->SetCreateUndoInformation( true );
00402     slicewriter->SetSliceImage( dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData()) );
00403     slicewriter->SetSliceDimension( m_LastSliceDimension );
00404     slicewriter->SetSliceIndex( m_LastSliceIndex );
00405     slicewriter->SetTimeStep( m_TimeStep[m_LastSliceDimension] );
00406     slicewriter->Update();
00407     m_FeedbackNode->SetData(NULL);
00408     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00409   }
00410 }
00411 
00412 void QmitkSlicesInterpolator::AcceptAllInterpolations(unsigned int windowID)
00413 {
00414   // first creates a 3D diff image, then applies this diff to the segmentation
00415   if (m_Segmentation)
00416   {
00417     int sliceDimension(-1);
00418     int dummySliceIndex(-1);
00419     if (!GetSliceForWindowsID(windowID, sliceDimension, dummySliceIndex))
00420     {
00421       return; // cannot determine slice orientation
00422     }
00423 
00424     //making interpolation separately undoable
00425     mitk::UndoStackItem::IncCurrObjectEventId();
00426     mitk::UndoStackItem::IncCurrGroupEventId();
00427     mitk::UndoStackItem::ExecuteIncrement(); 
00428 
00429     // create a diff image for the undo operation
00430     mitk::Image::Pointer diffImage = mitk::Image::New();
00431     diffImage->Initialize( m_Segmentation );
00432     mitk::PixelType pixelType( typeid(short signed int) );
00433     diffImage->Initialize( pixelType, 3, m_Segmentation->GetDimensions() );
00434 
00435     memset( diffImage->GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
00436     // now the diff image is all 0
00437 
00438     unsigned int timeStep( m_TimeStep[windowID] );
00439 
00440     // a slicewriter to create the diff image
00441     mitk::OverwriteSliceImageFilter::Pointer diffslicewriter = mitk::OverwriteSliceImageFilter::New();
00442     diffslicewriter->SetCreateUndoInformation( false );
00443     diffslicewriter->SetInput( diffImage );
00444     diffslicewriter->SetSliceDimension( sliceDimension );
00445     diffslicewriter->SetTimeStep( timeStep );
00446 
00447     unsigned int totalChangedSlices(0);
00448     unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
00449     mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
00450     for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
00451     {
00452       mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, timeStep );
00453       if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
00454       {
00455         diffslicewriter->SetSliceImage( interpolation );
00456         diffslicewriter->SetSliceIndex( sliceIndex );
00457         diffslicewriter->Update();
00458         ++totalChangedSlices;
00459       }
00460       mitk::ProgressBar::GetInstance()->Progress();
00461     }
00462 
00463     if (totalChangedSlices > 0)
00464     {
00465       // store undo stack items
00466       if ( true )
00467       {
00468         // create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
00469         mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
00470         mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
00471         undoOp->SetFactor( -1.0 );
00472         std::stringstream comment;
00473         comment << "Accept all interpolations (" << totalChangedSlices << ")";
00474         mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
00475         mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
00476 
00477         // acutally apply the changes here
00478         mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
00479       }
00480     }
00481 
00482     m_FeedbackNode->SetData(NULL);
00483     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00484   }
00485 }
00486 void QmitkSlicesInterpolator::FinishInterpolation(int windowID)
00487 {
00488   //this redirect is for calling from outside
00489 
00490   if (windowID < 0)
00491     OnAcceptAllInterpolationsClicked();
00492   else
00493     AcceptAllInterpolations( (unsigned int)windowID );
00494 }
00495 
00496 void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
00497 {
00498   QMenu orientationPopup(this);
00499   std::map<QAction*, unsigned int>::const_iterator it;
00500   for(it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
00501     orientationPopup.addAction(it->first);
00502 
00503   connect( &orientationPopup, SIGNAL(triggered(QAction*)), this, SLOT(OnAcceptAllPopupActivated(QAction*)) );
00504 
00505   orientationPopup.exec( QCursor::pos() );
00506 }
00507 
00508 void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
00509 {
00510   try
00511   {
00512     std::map<QAction*, unsigned int>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
00513     if (iter != ACTION_TO_SLICEDIMENSION.end())
00514     {
00515       int windowID = iter->second;
00516       AcceptAllInterpolations( windowID );
00517     }
00518 
00519   }
00520   catch(...)
00521   {
00522     std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
00523   }
00524 }
00525 
00526 void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
00527 {
00528   m_InterpolationEnabled = on;
00529 
00530   try
00531   {
00532     if ( m_DataStorage.IsNotNull() )
00533     {
00534       if (on)
00535       {
00536         m_DataStorage->Add( m_FeedbackNode );
00537       }
00538       else
00539       {
00540         m_DataStorage->Remove( m_FeedbackNode );
00541       }
00542     }
00543   }
00544   catch(...)
00545   {
00546     // don't care (double add/remove)
00547   }
00548 
00549   if (m_ToolManager)
00550   {
00551     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
00552     mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
00553     QWidget::setEnabled( workingNode != NULL );
00554 
00555     m_BtnAcceptAllInterpolations->setEnabled( on );
00556     m_BtnAcceptInterpolation->setEnabled( on );
00557     m_FeedbackNode->SetVisibility( on );
00558 
00559     if (!on)
00560     {
00561       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00562       return;
00563     }
00564 
00565     if (workingNode)
00566     {
00567       m_FeedbackNode->ReplaceProperty( "color", workingNode->GetProperty("color") ); // use the same color as the original image (but outline - see constructor)
00568       mitk::Image* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
00569       if (segmentation)
00570       {
00571         m_Interpolator->SetSegmentationVolume( segmentation );
00572 
00573         if (referenceNode)
00574         {
00575           mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
00576           m_Interpolator->SetReferenceVolume( referenceImage ); // may be NULL
00577         }
00578       }
00579     }
00580   }
00581 
00582   UpdateVisibleSuggestion();
00583 }
00584 
00585 void QmitkSlicesInterpolator::EnableInterpolation(bool on)
00586 {
00587   // only to be called from the outside world
00588   // just a redirection to OnInterpolationActivated
00589   OnInterpolationActivated(on);
00590 }
00591 
00592 void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
00593 {
00594   if (m_InterpolationEnabled)
00595   {
00596     // determine which one is the current view, try to do an initial interpolation
00597     mitk::BaseRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
00598     if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
00599     {
00600       const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
00601       if (timeSlicedGeometry)
00602       {
00603         mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeSlicedGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
00604 
00605         std::string s;
00606         if ( renderer->GetCurrentWorldGeometry2DNode() && renderer->GetCurrentWorldGeometry2DNode()->GetName(s) )
00607         {
00608                if (s == "widget1Plane")
00609           {
00610             TranslateAndInterpolateChangedSlice( event, 2 );
00611           }
00612           else if (s == "widget2Plane")
00613           {
00614             TranslateAndInterpolateChangedSlice( event, 0 );
00615           }
00616           else if (s == "widget3Plane")
00617           {
00618             TranslateAndInterpolateChangedSlice( event, 1 );
00619           }
00620         }
00621       }
00622     }
00623   }
00624 
00625   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00626 }
00627 
00628 void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject& /*e*/)
00629 {
00630   // something (e.g. undo) changed the interpolation info, we should refresh our display
00631   UpdateVisibleSuggestion();
00632 }
00633 
00634 bool QmitkSlicesInterpolator::GetSliceForWindowsID(unsigned windowID, int& sliceDimension, int& sliceIndex)
00635 {
00636   mitk::BaseRenderer* renderer(NULL);
00637 
00638   // find sliceDimension for windowID:
00639   //   windowID 2: transversal window = renderWindow1
00640   //   windowID 1: frontal window = renderWindow3
00641   //   windowID 0: sagittal window = renderWindow2
00642   if ( m_MultiWidget )
00643   {
00644     switch (windowID)
00645     {
00646     case 2:
00647     default:
00648       renderer = m_MultiWidget->mitkWidget1->GetRenderer();
00649       break;
00650     case 1:
00651       renderer = m_MultiWidget->mitkWidget3->GetRenderer();
00652       break;
00653     case 0:
00654       renderer = m_MultiWidget->mitkWidget2->GetRenderer();
00655       break;
00656     }
00657   }
00658 
00659   if ( m_Segmentation && renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
00660   {
00661     const mitk::TimeSlicedGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeSlicedGeometry*>( renderer->GetWorldGeometry() );
00662     if (timeSlicedGeometry)
00663     {
00664       mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeSlicedGeometry->GetGeometry3D(m_TimeStep[windowID]));
00665       if (slicedGeometry)
00666       {
00667         mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( renderer->GetSlice() ));
00668         Interpolate( plane, m_TimeStep[windowID] );
00669         return mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, sliceDimension, sliceIndex );
00670       }
00671     }
00672   }
00673 
00674   return false;
00675 }
00676 
00677 void QmitkSlicesInterpolator::OnMultiWidgetDeleted(QObject*)
00678 {
00679   if (m_MultiWidget)
00680   {
00681     m_MultiWidget = NULL;
00682   }
00683 }
00684