mitk: QmitkRigidRegistrationView.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$
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 "QmitkRigidRegistrationView.h"
00019 
00020 #include "QmitkStdMultiWidget.h"
00021 #include "QmitkCommonFunctionality.h"
00022 #include "qinputdialog.h"
00023 #include "qmessagebox.h"
00024 #include "qcursor.h"
00025 #include "qapplication.h"
00026 #include "qradiobutton.h"
00027 #include "qslider.h"
00028 #include "qtooltip.h"
00029 
00030 #include <vtkTransform.h>
00031 
00032 #include "mitkDataNodeObject.h"
00033 
00034 #include "berryIWorkbenchWindow.h"
00035 #include "berryISelectionService.h"
00036 
00037 
00038 const std::string QmitkRigidRegistrationView::VIEW_ID = "org.mitk.views.rigidregistration";
00039 
00040 using namespace berry;
00041 
00042 struct SelListenerRigidRegistration : ISelectionListener
00043 {
00044   berryObjectMacro(SelListenerRigidRegistration);
00045 
00046   SelListenerRigidRegistration(QmitkRigidRegistrationView* view)
00047   {
00048     m_View = view;
00049   }
00050 
00051   void DoSelectionChanged(ISelection::ConstPointer selection)
00052   {
00053 //    if (!m_View->IsVisible())
00054 //      return;
00055     // save current selection in member variable
00056     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
00057 
00058     // do something with the selected items
00059     if(m_View->m_CurrentSelection)
00060     {
00061       if (m_View->m_CurrentSelection->Size() != 2)
00062       {
00063         if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
00064         {
00065           m_View->m_Controls.m_StatusLabel->show();
00066           m_View->m_Controls.TextLabelFixed->hide();
00067           m_View->m_Controls.m_FixedLabel->hide();
00068           m_View->m_Controls.TextLabelMoving->hide();
00069           m_View->m_Controls.m_MovingLabel->hide();
00070           m_View->m_Controls.m_OpacityLabel->setEnabled(false);
00071           m_View->m_Controls.m_OpacitySlider->setEnabled(false);
00072           m_View->m_Controls.label->setEnabled(false);
00073           m_View->m_Controls.label_2->setEnabled(false);
00074           m_View->m_Controls.m_ShowRedGreenValues->setEnabled(false);
00075           m_View->m_Controls.m_SwitchImages->hide();
00076         }
00077       }
00078       else
00079       {
00080         m_View->m_Controls.m_StatusLabel->hide();
00081         bool foundFixedImage = false;
00082         mitk::DataNode::Pointer fixedNode;
00083         // iterate selection
00084         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
00085           i != m_View->m_CurrentSelection->End(); ++i)
00086         {
00087           // extract datatree node
00088           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00089           {
00090             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00091             // only look at interesting types
00092             if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
00093             {
00094               if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
00095               {
00096                 m_View->m_Controls.m_StatusLabel->show();
00097                 QMessageBox::information( NULL, "RigidRegistration", "Only 2D or 3D images can be processed.", QMessageBox::Ok );
00098                 return;
00099               }
00100               if (foundFixedImage == false)
00101               {
00102                 fixedNode = node;
00103                 foundFixedImage = true;
00104               }
00105               else
00106               {
00107                 m_View->SetImagesVisible(selection);
00108                 m_View->FixedSelected(fixedNode);
00109                 m_View->MovingSelected(node);
00110                 m_View->m_Controls.m_StatusLabel->hide();
00111                 m_View->m_Controls.TextLabelFixed->show();
00112                 m_View->m_Controls.m_FixedLabel->show();
00113                 m_View->m_Controls.TextLabelMoving->show();
00114                 m_View->m_Controls.m_MovingLabel->show();
00115                 m_View->m_Controls.m_OpacityLabel->setEnabled(true);
00116                 m_View->m_Controls.m_OpacitySlider->setEnabled(true);
00117                 m_View->m_Controls.label->setEnabled(true);
00118                 m_View->m_Controls.label_2->setEnabled(true);
00119                 m_View->m_Controls.m_ShowRedGreenValues->setEnabled(true);
00120               }
00121             }
00122             else
00123             {
00124               m_View->m_Controls.m_StatusLabel->show();
00125               return;
00126             }
00127           }
00128         }
00129       }
00130     }
00131     else if (m_View->m_FixedNode.IsNull() || m_View->m_MovingNode.IsNull())
00132     {
00133       m_View->m_Controls.m_StatusLabel->show();
00134     }
00135   }
00136 
00137   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
00138   {
00139     // check, if selection comes from datamanager
00140     if (part)
00141     {
00142       QString partname(part->GetPartName().c_str());
00143       if(partname.compare("Datamanager")==0)
00144       {
00145         // apply selection
00146         DoSelectionChanged(selection);
00147       }
00148     }
00149   }
00150 
00151   QmitkRigidRegistrationView* m_View;
00152 };
00153 
00154 QmitkRigidRegistrationView::QmitkRigidRegistrationView(QObject * /*parent*/, const char * /*name*/)
00155 : QmitkFunctionality(), m_MultiWidget(NULL), m_MovingNode(NULL), m_MovingMaskNode(NULL), m_FixedNode(NULL), m_FixedMaskNode(NULL),
00156   m_ShowRedGreen(false), m_Opacity(0.5), m_OriginalOpacity(1.0), m_Deactivated(false),m_FixedDimension(0), m_MovingDimension(0)
00157 {
00158   m_TranslateSliderPos[0] = 0;
00159   m_TranslateSliderPos[1] = 0;
00160   m_TranslateSliderPos[2] = 0;
00161 
00162   m_RotateSliderPos[0] = 0;
00163   m_RotateSliderPos[1] = 0;
00164   m_RotateSliderPos[2] = 0;
00165 
00166   m_ScaleSliderPos[0] = 0;
00167   m_ScaleSliderPos[1] = 0;
00168   m_ScaleSliderPos[2] = 0;
00169 
00170   translationParams = new int[3];
00171   rotationParams = new int[3];
00172   scalingParams = new int[3];
00173 
00174   m_TimeStepperAdapter = NULL;
00175 
00176   this->GetDataStorage()->RemoveNodeEvent.AddListener(mitk::MessageDelegate1<QmitkRigidRegistrationView,
00177     const mitk::DataNode*> ( this, &QmitkRigidRegistrationView::DataNodeHasBeenRemoved ));
00178 }
00179 
00180 QmitkRigidRegistrationView::~QmitkRigidRegistrationView()
00181 {
00182   if(m_SelListener.IsNotNull())
00183   {
00184     berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
00185     if(s)
00186       s->RemovePostSelectionListener(m_SelListener);
00187     m_SelListener = NULL;
00188   }
00189 }
00190 
00191 void QmitkRigidRegistrationView::CreateQtPartControl(QWidget* parent)
00192 {
00193   m_Controls.setupUi(parent);
00194   m_Controls.m_ManualFrame->hide();
00195   m_Controls.timeSlider->hide();
00196   m_Controls.TextLabelFixed->hide();
00197   m_Controls.m_FixedLabel->hide();
00198   m_Controls.TextLabelMoving->hide();
00199   m_Controls.m_MovingLabel->hide();
00200   m_Controls.m_UseFixedImageMask->hide();
00201   m_Controls.m_UseMovingImageMask->hide();
00202   m_Controls.m_OpacityLabel->setEnabled(false);
00203   m_Controls.m_OpacitySlider->setEnabled(false);
00204   m_Controls.label->setEnabled(false);
00205   m_Controls.label_2->setEnabled(false);
00206   m_Controls.m_ShowRedGreenValues->setEnabled(false);
00207   m_Controls.m_SwitchImages->hide();
00208   if (m_Controls.m_RigidTransform->currentIndex() == 1)
00209   {
00210     m_Controls.frame->show();
00211   }
00212   else
00213   {
00214     m_Controls.frame->hide();
00215   }
00216   m_Controls.m_ManualFrame->setEnabled(false);
00217   m_Parent->setEnabled(false);
00218 
00219   this->CreateConnections();
00220   this->CheckCalculateEnabled();
00221 }
00222 
00223 void QmitkRigidRegistrationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
00224 {
00225   m_Parent->setEnabled(true);
00226   m_MultiWidget = &stdMultiWidget;
00227   m_MultiWidget->SetWidgetPlanesVisibility(true);
00228 }
00229 
00230 void QmitkRigidRegistrationView::StdMultiWidgetNotAvailable()
00231 {
00232   m_Parent->setEnabled(false);
00233   m_MultiWidget = NULL;
00234 }
00235 
00236 void QmitkRigidRegistrationView::CreateConnections()
00237 {
00238   connect( m_Controls.m_ManualRegistrationCheckbox, SIGNAL(toggled(bool)), this, SLOT(ShowManualRegistrationFrame(bool)));
00239   connect((QObject*)(m_Controls.m_SwitchImages),SIGNAL(clicked()),this,SLOT(SwitchImages()));
00240   connect(m_Controls.m_ShowRedGreenValues, SIGNAL(toggled(bool)), this, SLOT(ShowRedGreen(bool)));
00241   connect(m_Controls.m_UseFixedImageMask, SIGNAL(toggled(bool)), this, SLOT(UseFixedMaskImageChecked(bool)));
00242   connect(m_Controls.m_UseMovingImageMask, SIGNAL(toggled(bool)), this, SLOT(UseMovingMaskImageChecked(bool)));
00243   connect(m_Controls.m_RigidTransform, SIGNAL(currentChanged(int)), this, SLOT(TabChanged(int)));
00244   connect(m_Controls.m_OpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityUpdate(int)));
00245   connect(m_Controls.m_CalculateTransformation, SIGNAL(clicked()), this, SLOT(Calculate()));
00246   connect(m_Controls.m_UndoTransformation,SIGNAL(clicked()),this,SLOT(UndoTransformation()));
00247   connect(m_Controls.m_RedoTransformation,SIGNAL(clicked()),this,SLOT(RedoTransformation()));
00248   connect(m_Controls.m_AutomaticTranslation,SIGNAL(clicked()),this,SLOT(AlignCenters()));
00249   connect(m_Controls.m_StopOptimization,SIGNAL(clicked()), this , SLOT(StopOptimizationClicked()));
00250   connect(m_Controls.m_XTransSlider, SIGNAL(valueChanged(int)), this, SLOT(xTrans_valueChanged(int)));
00251   connect(m_Controls.m_YTransSlider, SIGNAL(valueChanged(int)), this, SLOT(yTrans_valueChanged(int)));
00252   connect(m_Controls.m_ZTransSlider, SIGNAL(valueChanged(int)), this, SLOT(zTrans_valueChanged(int)));
00253   connect(m_Controls.m_XRotSlider, SIGNAL(valueChanged(int)), this, SLOT(xRot_valueChanged(int)));
00254   connect(m_Controls.m_YRotSlider, SIGNAL(valueChanged(int)), this, SLOT(yRot_valueChanged(int)));
00255   connect(m_Controls.m_ZRotSlider, SIGNAL(valueChanged(int)), this, SLOT(zRot_valueChanged(int)));
00256   connect(m_Controls.m_XScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(xScale_valueChanged(int)));
00257   connect(m_Controls.m_YScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(yScale_valueChanged(int)));
00258   connect(m_Controls.m_ZScaleSlider, SIGNAL(valueChanged(int)), this, SLOT(zScale_valueChanged(int)));
00259   connect(m_Controls.m_LoadRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationParameter()));
00260   connect(m_Controls.m_SaveRigidRegistrationParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationParameter()));
00261   connect(m_Controls.m_LoadRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(LoadRigidRegistrationTestParameter()));
00262   connect(m_Controls.m_SaveRigidRegistrationTestParameter, SIGNAL(clicked()), m_Controls.qmitkRigidRegistrationSelector1, SLOT(SaveRigidRegistrationTestParameter()));
00263   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(OptimizerChanged(double)),this,SLOT(SetOptimizerValue( double )));
00264   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(TransformChanged()),this,SLOT(CheckCalculateEnabled()));
00265   connect(m_Controls.qmitkRigidRegistrationSelector1,SIGNAL(AddNewTransformationToUndoList()),this,SLOT(AddNewTransformationToUndoList()));
00266 }
00267 
00268 void QmitkRigidRegistrationView::Activated()
00269 {
00270   m_Deactivated = false;
00271   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00272   QmitkFunctionality::Activated();
00273   if (m_SelListener.IsNull())
00274   {
00275     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
00276     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00277     berry::ISelection::ConstPointer sel(
00278       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00279     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00280     m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
00281   }
00282   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
00283   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
00284   this->ClearTransformationLists();
00285   this->CheckCalculateEnabled();
00286   /*
00287   m_Deactivated = false;
00288     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00289     QmitkFunctionality::Activated();
00290     if (m_SelListener.IsNull())
00291     {
00292       m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
00293       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/ *"org.mitk.views.datamanager",* / m_SelListener);
00294       berry::ISelection::ConstPointer sel(
00295         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00296       m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00297       m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
00298     }
00299     this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
00300     this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
00301     this->ClearTransformationLists();
00302     this->CheckCalculateEnabled();*/
00303 
00304 }
00305 
00306 void QmitkRigidRegistrationView::Visible()
00307 {
00308   /*
00309   m_Deactivated = false;
00310   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00311   QmitkFunctionality::Activated();
00312   if (m_SelListener.IsNull())
00313   {
00314     m_SelListener = berry::ISelectionListener::Pointer(new SelListenerRigidRegistration(this));
00315     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener("org.mitk.views.datamanager", m_SelListener);
00316     berry::ISelection::ConstPointer sel(
00317       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00318     m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00319     m_SelListener.Cast<SelListenerRigidRegistration>()->DoSelectionChanged(sel);
00320   }
00321   this->OpacityUpdate(m_Controls.m_OpacitySlider->value());
00322   this->ShowRedGreen(m_Controls.m_ShowRedGreenValues->isChecked());
00323   this->ClearTransformationLists();
00324   this->CheckCalculateEnabled();*/
00325 }
00326 
00327 void QmitkRigidRegistrationView::Deactivated()
00328 {
00329   m_Deactivated = true;
00330   this->SetImageColor(false);
00331   if (m_FixedNode.IsNotNull())
00332     m_FixedNode->SetOpacity(1.0);
00333   m_FixedNode = NULL;
00334   m_MovingNode = NULL;
00335   this->ClearTransformationLists();
00336   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
00337   if(s)
00338     s->RemovePostSelectionListener(m_SelListener);
00339   m_SelListener = NULL;
00340   /*
00341   m_Deactivated = true;
00342     this->SetImageColor(false);
00343     m_FixedNode = NULL;
00344     m_MovingNode = NULL;
00345     this->ClearTransformationLists();
00346     berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
00347     if(s)
00348       s->RemovePostSelectionListener(m_SelListener);
00349     m_SelListener = NULL;
00350     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00351     QmitkFunctionality::Deactivated();*/
00352 
00353 }
00354 
00355 void QmitkRigidRegistrationView::Hidden()
00356 {
00357   /*m_Deactivated = true;
00358   this->SetImageColor(false);
00359   m_FixedNode = NULL;
00360   m_MovingNode = NULL;
00361   this->ClearTransformationLists();
00362   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
00363   if(s)
00364     s->RemovePostSelectionListener(m_SelListener);
00365   m_SelListener = NULL;
00366   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00367   //QmitkFunctionality::Deactivated();*/
00368 }
00369 
00370 void QmitkRigidRegistrationView::DataNodeHasBeenRemoved(const mitk::DataNode* node)
00371 {
00372   if(node == m_FixedNode || node == m_MovingNode)
00373   {
00374     m_Controls.m_StatusLabel->show();
00375     m_Controls.TextLabelFixed->hide();
00376     m_Controls.m_FixedLabel->hide();
00377     m_Controls.TextLabelMoving->hide();
00378     m_Controls.m_MovingLabel->hide();
00379     m_Controls.m_OpacityLabel->setEnabled(false);
00380     m_Controls.m_OpacitySlider->setEnabled(false);
00381     m_Controls.label->setEnabled(false);
00382     m_Controls.label_2->setEnabled(false);
00383     m_Controls.m_ShowRedGreenValues->setEnabled(false);
00384     m_Controls.m_SwitchImages->hide();
00385   }
00386 }
00387 
00388 void QmitkRigidRegistrationView::FixedSelected(mitk::DataNode::Pointer fixedImage)
00389 {
00390   if (m_FixedNode.IsNotNull())
00391   {
00392     this->SetImageColor(false);
00393     m_FixedNode->SetOpacity(1.0);
00394   }
00395   m_FixedNode = fixedImage;
00396   if (m_FixedNode.IsNotNull())
00397   {
00398     m_FixedNode->SetOpacity(0.5);
00399     m_FixedNode->SetVisibility(true);
00400     m_Controls.TextLabelFixed->setText(QString::fromStdString(m_FixedNode->GetName()));
00401     m_Controls.m_FixedLabel->show();
00402     m_Controls.TextLabelFixed->show();
00403     m_Controls.m_SwitchImages->show();
00404     mitk::ColorProperty::Pointer colorProperty;
00405     colorProperty = dynamic_cast<mitk::ColorProperty*>(m_FixedNode->GetProperty("color"));
00406     if ( colorProperty.IsNotNull() )
00407     {
00408       m_FixedColor = colorProperty->GetColor();
00409     }
00410     this->SetImageColor(m_ShowRedGreen);
00411     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00412     if (dynamic_cast<mitk::Image*>(m_FixedNode->GetData()))
00413     {
00414       m_FixedDimension = dynamic_cast<mitk::Image*>(m_FixedNode->GetData())->GetDimension();
00415       m_Controls.qmitkRigidRegistrationSelector1->SetFixedDimension(m_FixedDimension);
00416       m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
00417     }
00418 
00419     bool hasMask = false;
00420     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_FixedNode);
00421     unsigned long size;
00422     size = children->Size();
00423     for (unsigned long i = 0; i < size; ++i)
00424     {
00425       mitk::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
00426       if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
00427       {
00428         m_FixedMaskNode = children->GetElement(i);
00429         hasMask = true;
00430         this->CheckForMaskImages();
00431         break;
00432       }
00433     }
00434     if (!hasMask)
00435     {
00436       this->CheckForMaskImages();
00437       m_FixedMaskNode = NULL;
00438     }
00439   }
00440   else
00441   {
00442     m_Controls.m_FixedLabel->hide();
00443     m_Controls.TextLabelFixed->hide();
00444     m_Controls.m_SwitchImages->hide();
00445   }
00446   this->CheckCalculateEnabled();
00447   if(this->GetActiveStdMultiWidget())
00448   {
00449     m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls.timeSlider, m_MultiWidget->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromRigidRegistration");
00450     connect( m_TimeStepperAdapter, SIGNAL( Refetch() ), this, SLOT( UpdateTimestep() ) );
00451   }
00452 }
00453 
00454 void QmitkRigidRegistrationView::MovingSelected(mitk::DataNode::Pointer movingImage)
00455 {
00456   if (m_MovingNode.IsNotNull())
00457   {
00458     m_MovingNode->SetOpacity(m_OriginalOpacity);
00459     if (m_FixedNode == m_MovingNode)
00460       m_FixedNode->SetOpacity(0.5);
00461     this->SetImageColor(false);
00462   }
00463   m_MovingNode = movingImage;
00464   if (m_MovingNode.IsNotNull())
00465   {
00466     m_MovingNode->SetVisibility(true);
00467     m_Controls.TextLabelMoving->setText(QString::fromStdString(m_MovingNode->GetName()));
00468     m_Controls.m_MovingLabel->show();
00469     m_Controls.TextLabelMoving->show();
00470     mitk::ColorProperty::Pointer colorProperty;
00471     colorProperty = dynamic_cast<mitk::ColorProperty*>(m_MovingNode->GetProperty("color"));
00472     if ( colorProperty.IsNotNull() )
00473     {
00474       m_MovingColor = colorProperty->GetColor();
00475     }
00476     this->SetImageColor(m_ShowRedGreen);
00477     m_MovingNode->GetFloatProperty("opacity", m_OriginalOpacity);
00478     this->OpacityUpdate(m_Opacity);
00479 
00480     bool hasMask = false;
00481     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00482     m_Controls.qmitkRigidRegistrationSelector1->SetMovingNodeChildren(children);
00483     unsigned long size;
00484     size = children->Size();
00485     for (unsigned long i = 0; i < size; ++i)
00486     {
00487       mitk::BoolProperty::Pointer isMaskProp = dynamic_cast<mitk::BoolProperty*>(children->GetElement(i)->GetProperty("binary"));
00488       if(isMaskProp.IsNotNull() && isMaskProp->GetValue() == true)
00489       {
00490         m_MovingMaskNode = children->GetElement(i);
00491         hasMask = true;
00492         this->CheckForMaskImages();
00493         break;
00494       }
00495     }
00496     if (!hasMask)
00497     {
00498       m_MovingMaskNode = NULL;
00499       this->CheckForMaskImages();
00500     }
00501   }
00502   else
00503   {
00504     m_Controls.m_MovingLabel->hide();
00505     m_Controls.TextLabelMoving->hide();
00506   }
00507   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00508   this->MovingImageChanged();
00509   this->CheckCalculateEnabled();
00510 }
00511 
00512 bool QmitkRigidRegistrationView::CheckCalculate()
00513 {
00514   if(m_MovingNode==m_FixedNode)
00515     return false;
00516   return true;
00517 }
00518 
00519 void QmitkRigidRegistrationView::AddNewTransformationToUndoList()
00520 {
00521   mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
00522   m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
00523   unsigned long size;
00524   mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00525   size = children->Size();
00526   std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
00527   for (unsigned long i = 0; i < size; ++i)
00528   {
00529     childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
00530   }
00531   m_UndoChildGeometryList.push_back(childGeometries);
00532   m_RedoGeometryList.clear();
00533   m_RedoChildGeometryList.clear();
00534   this->SetUndoEnabled(true);
00535   this->SetRedoEnabled(false);
00536 }
00537 
00538 void QmitkRigidRegistrationView::UndoTransformation()
00539 {
00540   if(!m_UndoGeometryList.empty())
00541   {
00542     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
00543     m_RedoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
00544     unsigned long size;
00545     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00546     size = children->Size();
00547     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
00548     for (unsigned long i = 0; i < size; ++i)
00549     {
00550       childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
00551     }
00552     m_RedoChildGeometryList.push_back(childGeometries);
00553 
00554     movingData->SetGeometry(m_UndoGeometryList.back());
00555     m_UndoGeometryList.pop_back();
00556     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
00557     oldChildGeometries = m_UndoChildGeometryList.back();
00558     m_UndoChildGeometryList.pop_back();
00559     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
00560     for (unsigned long j = 0; j < size; ++j)
00561     {
00562       iter = oldChildGeometries.find(children->GetElement(j));
00563       children->GetElement(j)->GetData()->SetGeometry((*iter).second);
00564     }
00565 
00566     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
00567     //is still pointing to the old one. Workaround: delete mapper
00568     m_MovingNode->SetMapper(1, NULL);
00569     mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
00570 
00571     movingData->GetTimeSlicedGeometry()->UpdateInformation();
00572     this->SetRedoEnabled(true);
00573     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00574   }
00575   if(!m_UndoGeometryList.empty())
00576   {
00577     this->SetUndoEnabled(true);
00578   }
00579   else
00580   {
00581     this->SetUndoEnabled(false);
00582   }
00583   this->CheckCalculateEnabled();
00584 }
00585 
00586 void QmitkRigidRegistrationView::RedoTransformation()
00587 {
00588   if(!m_RedoGeometryList.empty())
00589   {
00590     mitk::BaseData::Pointer movingData = m_MovingNode->GetData();
00591     m_UndoGeometryList.push_back(static_cast<mitk::Geometry3D *>(movingData->GetGeometry(0)->Clone().GetPointer()));
00592     unsigned long size;
00593     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00594     size = children->Size();
00595     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> childGeometries;
00596     for (unsigned long i = 0; i < size; ++i)
00597     {
00598       childGeometries.insert(std::pair<mitk::DataNode::Pointer, mitk::Geometry3D*>(children->GetElement(i), children->GetElement(i)->GetData()->GetGeometry()));
00599     }
00600     m_UndoChildGeometryList.push_back(childGeometries);
00601 
00602     movingData->SetGeometry(m_RedoGeometryList.back());
00603     m_RedoGeometryList.pop_back();
00604 
00605     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*> oldChildGeometries;
00606     oldChildGeometries = m_RedoChildGeometryList.back();
00607     m_RedoChildGeometryList.pop_back();
00608     std::map<mitk::DataNode::Pointer, mitk::Geometry3D*>::iterator iter;
00609     for (unsigned long j = 0; j < size; ++j)
00610     {
00611       iter = oldChildGeometries.find(children->GetElement(j));
00612       children->GetElement(j)->GetData()->SetGeometry((*iter).second);
00613     }
00614 
00615     //\FIXME when geometry is substituted the matrix referenced by the actor created by the mapper
00616     //is still pointing to the old one. Workaround: delete mapper
00617     m_MovingNode->SetMapper(1, NULL);
00618     mitk::RenderingManager::GetInstance()->RequestUpdate(m_MultiWidget->mitkWidget4->GetRenderWindow());
00619 
00620     movingData->GetTimeSlicedGeometry()->UpdateInformation();
00621     this->SetUndoEnabled(true);
00622     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00623   }
00624   if(!m_RedoGeometryList.empty())
00625   {
00626     this->SetRedoEnabled(true);
00627   }
00628   else
00629   {
00630     this->SetRedoEnabled(false);
00631   }
00632 }
00633 
00634 void QmitkRigidRegistrationView::ShowRedGreen(bool redGreen)
00635 {
00636   m_ShowRedGreen = redGreen;
00637   this->SetImageColor(m_ShowRedGreen);
00638 }
00639 
00640 void QmitkRigidRegistrationView::SetImageColor(bool redGreen)
00641 {
00642   if (!redGreen && m_FixedNode.IsNotNull())
00643   {
00644     m_FixedNode->SetColor(m_FixedColor);
00645   }
00646   if (!redGreen && m_MovingNode.IsNotNull())
00647   {
00648     m_MovingNode->SetColor(m_MovingColor);
00649   }
00650   if (redGreen && m_FixedNode.IsNotNull())
00651   {
00652     m_FixedNode->SetColor(1.0f, 0.0f, 0.0f);
00653   }
00654   if (redGreen && m_MovingNode.IsNotNull())
00655   {
00656     m_MovingNode->SetColor(0.0f, 1.0f, 0.0f);
00657   }
00658   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00659 }
00660 
00661 void QmitkRigidRegistrationView::OpacityUpdate(float opacity)
00662 {
00663   m_Opacity = opacity;
00664   if (m_MovingNode.IsNotNull())
00665   {
00666     m_MovingNode->SetOpacity(m_Opacity);
00667   }
00668   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00669 }
00670 
00671 void QmitkRigidRegistrationView::OpacityUpdate(int opacity)
00672 {
00673   float fValue = ((float)opacity)/100.0f;
00674   this->OpacityUpdate(fValue);
00675 }
00676 
00677 void QmitkRigidRegistrationView::ClearTransformationLists()
00678 {
00679   this->SetUndoEnabled(false);
00680   this->SetRedoEnabled(false);
00681   m_UndoGeometryList.clear();
00682   m_UndoChildGeometryList.clear();
00683   m_RedoGeometryList.clear();
00684   m_RedoChildGeometryList.clear();
00685 }
00686 
00687 void QmitkRigidRegistrationView::Translate(int* translateVector)
00688 {
00689   if (m_MovingNode.IsNotNull())
00690   {
00691 
00692     mitk::Vector3D translateVec;
00693 
00694     translateVec[0] = translateVector[0] - m_TranslateSliderPos[0];
00695     translateVec[1] = translateVector[1] - m_TranslateSliderPos[1];
00696     translateVec[2] = translateVector[2] - m_TranslateSliderPos[2];
00697 
00698     m_TranslateSliderPos[0] = translateVector[0];
00699     m_TranslateSliderPos[1] = translateVector[1];
00700     m_TranslateSliderPos[2] = translateVector[2];
00701 
00702     vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
00703     translationMatrix->Identity();
00704 
00705     double (*transMatrix)[4] = translationMatrix->Element;
00706 
00707     transMatrix[0][3] = -translateVec[0];
00708     transMatrix[1][3] = -translateVec[1];
00709     transMatrix[2][3] = -translateVec[2];
00710 
00711     translationMatrix->Invert();
00712 
00713     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
00714     m_MovingNode->GetData()->Modified();
00715     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00716     unsigned long size;
00717     size = children->Size();
00718     mitk::DataNode::Pointer childNode;
00719     for (unsigned long i = 0; i < size; ++i)
00720     {
00721       childNode = children->GetElement(i);
00722       childNode->GetData()->GetGeometry()->Compose( translationMatrix );
00723       childNode->GetData()->Modified();
00724     }
00725     m_RedoGeometryList.clear();
00726 
00727     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00728   }
00729 }
00730 
00731 void QmitkRigidRegistrationView::Rotate(int* rotateVector)
00732 {
00733   if (m_MovingNode.IsNotNull())
00734   {
00735     mitk::Vector3D rotateVec;
00736 
00737     rotateVec[0] = rotateVector[0] - m_RotateSliderPos[0];
00738     rotateVec[1] = rotateVector[1] - m_RotateSliderPos[1];
00739     rotateVec[2] = rotateVector[2] - m_RotateSliderPos[2];
00740 
00741     m_RotateSliderPos[0] = rotateVector[0];
00742     m_RotateSliderPos[1] = rotateVector[1];
00743     m_RotateSliderPos[2] = rotateVector[2];
00744 
00745     vtkMatrix4x4* rotationMatrix = vtkMatrix4x4::New();
00746     vtkMatrix4x4* translationMatrix = vtkMatrix4x4::New();
00747     rotationMatrix->Identity();
00748     translationMatrix->Identity();
00749 
00750     double (*rotMatrix)[4] = rotationMatrix->Element;
00751     double (*transMatrix)[4] = translationMatrix->Element;
00752 
00753     mitk::Point3D centerBB = m_MovingNode->GetData()->GetGeometry()->GetCenter();
00754 
00755     transMatrix[0][3] = centerBB[0];
00756     transMatrix[1][3] = centerBB[1];
00757     transMatrix[2][3] = centerBB[2];
00758 
00759     translationMatrix->Invert();
00760 
00761     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
00762     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00763     unsigned long size;
00764     size = children->Size();
00765     mitk::DataNode::Pointer childNode;
00766     for (unsigned long i = 0; i < size; ++i)
00767     {
00768       childNode = children->GetElement(i);
00769       childNode->GetData()->GetGeometry()->Compose( translationMatrix );
00770       childNode->GetData()->Modified();
00771     }
00772 
00773     double radianX = rotateVec[0] * vnl_math::pi / 180;
00774     double radianY = rotateVec[1] * vnl_math::pi / 180;
00775     double radianZ = rotateVec[2] * vnl_math::pi / 180;
00776 
00777     if ( rotateVec[0] != 0 )
00778     {
00779       rotMatrix[1][1] = cos( radianX );
00780       rotMatrix[1][2] = -sin( radianX );
00781       rotMatrix[2][1] = sin( radianX );
00782       rotMatrix[2][2] = cos( radianX );
00783     }
00784     else if ( rotateVec[1] != 0 )
00785     {
00786       rotMatrix[0][0] = cos( radianY );
00787       rotMatrix[0][2] = sin( radianY );
00788       rotMatrix[2][0] = -sin( radianY );
00789       rotMatrix[2][2] = cos( radianY );
00790     }
00791     else if ( rotateVec[2] != 0 )
00792     {
00793       rotMatrix[0][0] = cos( radianZ );
00794       rotMatrix[0][1] = -sin( radianZ );
00795       rotMatrix[1][0] = sin( radianZ );
00796       rotMatrix[1][1] = cos( radianZ );
00797     }
00798 
00799     m_MovingNode->GetData()->GetGeometry()->Compose( rotationMatrix );
00800     for (unsigned long i = 0; i < size; ++i)
00801     {
00802       childNode = children->GetElement(i);
00803       childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
00804       childNode->GetData()->Modified();
00805     }
00806 
00807     translationMatrix->Invert();
00808 
00809     m_MovingNode->GetData()->GetGeometry()->Compose( translationMatrix );
00810     for (unsigned long i = 0; i < size; ++i)
00811     {
00812       childNode = children->GetElement(i);
00813       childNode->GetData()->GetGeometry()->Compose( rotationMatrix );
00814       childNode->GetData()->Modified();
00815     }
00816     m_MovingNode->GetData()->Modified();
00817     m_RedoGeometryList.clear();
00818     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00819   }
00820 }
00821 
00822 void QmitkRigidRegistrationView::Scale(int* scaleVector)
00823 {
00824   if (m_MovingNode.IsNotNull())
00825   {
00826 
00827     mitk::Vector3D scaleVec;
00828 
00829     scaleVec[0] = scaleVector[0] - m_ScaleSliderPos[0];
00830     scaleVec[1] = scaleVector[1] - m_ScaleSliderPos[1];
00831     scaleVec[2] = scaleVector[2] - m_ScaleSliderPos[2];
00832 
00833     m_ScaleSliderPos[0] = scaleVector[0];
00834     m_ScaleSliderPos[1] = scaleVector[1];
00835     m_ScaleSliderPos[2] = scaleVector[2];
00836 
00837     vtkMatrix4x4* scalingMatrix = vtkMatrix4x4::New();
00838     scalingMatrix->Identity();
00839 
00840     double (*scaleMatrix)[4] = scalingMatrix->Element;
00841 
00842     if (scaleVec[0] >= 0)
00843     {
00844       for(int i = 0; i<scaleVec[0]; i++)
00845       {
00846         scaleMatrix[0][0] *= 0.95;
00847       }
00848     }
00849     else
00850     {
00851       for(int i = 0; i<-scaleVec[0]; i++)
00852       {
00853         scaleMatrix[0][0] *= 1/0.95;
00854       }
00855     }
00856 
00857     if (scaleVec[1] >= 0)
00858     {
00859       for(int i = 0; i<scaleVec[1]; i++)
00860       {
00861         scaleMatrix[1][1] *= 0.95;
00862       }
00863     }
00864     else
00865     {
00866       for(int i = 0; i<-scaleVec[1]; i++)
00867       {
00868         scaleMatrix[1][1] *= 1/0.95;
00869       }
00870     }
00871 
00872     if (scaleVec[2] >= 0)
00873     {
00874       for(int i = 0; i<scaleVec[2]; i++)
00875       {
00876         scaleMatrix[2][2] *= 0.95;
00877       }
00878     }
00879     else
00880     {
00881       for(int i = 0; i<-scaleVec[2]; i++)
00882       {
00883         scaleMatrix[2][2] *= 1/0.95;
00884       }
00885     }
00886 
00887     scalingMatrix->Invert();
00888 
00889     m_MovingNode->GetData()->GetGeometry()->Compose( scalingMatrix );
00890     m_MovingNode->GetData()->Modified();
00891     mitk::DataStorage::SetOfObjects::ConstPointer children = this->GetDataStorage()->GetDerivations(m_MovingNode);
00892     unsigned long size;
00893     size = children->Size();
00894     mitk::DataNode::Pointer childNode;
00895     for (unsigned long i = 0; i < size; ++i)
00896     {
00897       childNode = children->GetElement(i);
00898       childNode->GetData()->GetGeometry()->Compose( scalingMatrix );
00899       childNode->GetData()->Modified();
00900     }
00901     m_RedoGeometryList.clear();
00902 
00903     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00904   }
00905 }
00906 
00907 void QmitkRigidRegistrationView::AlignCenters()
00908 {
00909   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
00910   {
00911     mitk::Point3D fixedPoint = m_FixedNode->GetData()->GetGeometry()->GetCenter();
00912     mitk::Point3D movingPoint = m_MovingNode->GetData()->GetGeometry()->GetCenter();
00913     mitk::Vector3D translateVec;
00914     translateVec =  fixedPoint - movingPoint;
00915     m_Controls.m_XTransSlider->setValue((int)m_Controls.m_XTransSlider->value() + (int)translateVec[0]);
00916     m_Controls.m_YTransSlider->setValue((int)m_Controls.m_YTransSlider->value() + (int)translateVec[1]);
00917     m_Controls.m_ZTransSlider->setValue((int)m_Controls.m_ZTransSlider->value() + (int)translateVec[2]);
00918   }
00919 }
00920 
00921 void QmitkRigidRegistrationView::SetUndoEnabled( bool enable )
00922 {
00923   m_Controls.m_UndoTransformation->setEnabled(enable);
00924 }
00925 
00926 void QmitkRigidRegistrationView::SetRedoEnabled( bool enable )
00927 {
00928   m_Controls.m_RedoTransformation->setEnabled(enable);
00929 }
00930 
00931 void QmitkRigidRegistrationView::CheckCalculateEnabled()
00932 {
00933   if (m_FixedNode.IsNotNull() && m_MovingNode.IsNotNull())
00934   {
00935     m_Controls.m_ManualFrame->setEnabled(true);
00936     m_Controls.m_CalculateTransformation->setEnabled(true);
00937     if ( (m_FixedDimension != m_MovingDimension && std::max<int>(m_FixedDimension, m_MovingDimension) != 4) || m_FixedDimension < 2 /*|| m_FixedDimension > 3*/)
00938     {
00939       m_Controls.m_CalculateTransformation->setEnabled(false);
00940     }
00941     else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 5 &&  (m_FixedDimension < 2) /*|| m_FixedDimension > 3)*/)
00942     {
00943       m_Controls.m_CalculateTransformation->setEnabled(false);
00944     }
00945     else if ((m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 4 && m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() < 13) && !(m_FixedDimension > 2))
00946     {
00947       m_Controls.m_CalculateTransformation->setEnabled(false);
00948     }
00949     else if (m_Controls.qmitkRigidRegistrationSelector1->GetSelectedTransform() > 12 &&  m_FixedDimension != 2)
00950     {
00951       m_Controls.m_CalculateTransformation->setEnabled(false);
00952     }
00953   }
00954   else
00955   {
00956     m_Controls.m_CalculateTransformation->setEnabled(false);
00957     m_Controls.m_ManualFrame->setEnabled(false);
00958   }
00959 }
00960 
00961 void QmitkRigidRegistrationView::xTrans_valueChanged( int v )
00962 {
00963   if (m_MovingNode.IsNotNull())
00964   {
00965     translationParams[0]=v;
00966     translationParams[1]=m_Controls.m_YTransSlider->value();
00967     translationParams[2]=m_Controls.m_ZTransSlider->value();
00968     Translate(translationParams);
00969   }
00970   else
00971   {
00972     MovingImageChanged();
00973   }
00974 }
00975 
00976 void QmitkRigidRegistrationView::yTrans_valueChanged( int v )
00977 {
00978   if (m_MovingNode.IsNotNull())
00979   {
00980     translationParams[0]=m_Controls.m_XTransSlider->value();
00981     translationParams[1]=v;
00982     translationParams[2]=m_Controls.m_ZTransSlider->value();
00983     Translate(translationParams);
00984   }
00985   else
00986   {
00987     MovingImageChanged();
00988   }
00989 }
00990 
00991 void QmitkRigidRegistrationView::zTrans_valueChanged( int v )
00992 {
00993   if (m_MovingNode.IsNotNull())
00994   {
00995     translationParams[0]=m_Controls.m_XTransSlider->value();
00996     translationParams[1]=m_Controls.m_YTransSlider->value();
00997     translationParams[2]=v;
00998     Translate(translationParams);
00999   }
01000   else
01001   {
01002     MovingImageChanged();
01003   }
01004 }
01005 
01006 void QmitkRigidRegistrationView::xRot_valueChanged( int v )
01007 {
01008   if (m_MovingNode.IsNotNull())
01009   {
01010     rotationParams[0]=v;
01011     rotationParams[1]=m_Controls.m_YRotSlider->value();
01012     rotationParams[2]=m_Controls.m_ZRotSlider->value();
01013     Rotate(rotationParams);
01014   }
01015   else
01016   {
01017     MovingImageChanged();
01018   }
01019 }
01020 
01021 void QmitkRigidRegistrationView::yRot_valueChanged( int v )
01022 {
01023   if (m_MovingNode.IsNotNull())
01024   {
01025     rotationParams[0]=m_Controls.m_XRotSlider->value();
01026     rotationParams[1]=v;
01027     rotationParams[2]=m_Controls.m_ZRotSlider->value();
01028     Rotate(rotationParams);
01029   }
01030   else
01031   {
01032     MovingImageChanged();
01033   }
01034 }
01035 
01036 void QmitkRigidRegistrationView::zRot_valueChanged( int v )
01037 {
01038   if (m_MovingNode.IsNotNull())
01039   {
01040     rotationParams[0]=m_Controls.m_XRotSlider->value();
01041     rotationParams[1]=m_Controls.m_YRotSlider->value();
01042     rotationParams[2]=v;
01043     Rotate(rotationParams);
01044   }
01045   else
01046   {
01047     MovingImageChanged();
01048   }
01049 }
01050 
01051 void QmitkRigidRegistrationView::xScale_valueChanged( int v )
01052 {
01053   if (m_MovingNode.IsNotNull())
01054   {
01055     scalingParams[0]=v;
01056     scalingParams[1]=m_Controls.m_YScaleSlider->value();
01057     scalingParams[2]=m_Controls.m_ZScaleSlider->value();
01058     Scale(scalingParams);
01059   }
01060   else
01061   {
01062     MovingImageChanged();
01063   }
01064 }
01065 
01066 void QmitkRigidRegistrationView::yScale_valueChanged( int v )
01067 {
01068   if (m_MovingNode.IsNotNull())
01069   {
01070     scalingParams[0]=m_Controls.m_XScaleSlider->value();
01071     scalingParams[1]=v;
01072     scalingParams[2]=m_Controls.m_ZScaleSlider->value();
01073     Scale(scalingParams);
01074   }
01075   else
01076   {
01077     MovingImageChanged();
01078   }
01079 }
01080 
01081 void QmitkRigidRegistrationView::zScale_valueChanged( int v )
01082 {
01083   if (m_MovingNode.IsNotNull())
01084   {
01085     scalingParams[0]=m_Controls.m_XScaleSlider->value();
01086     scalingParams[1]=m_Controls.m_YScaleSlider->value();
01087     scalingParams[2]=v;
01088     Scale(scalingParams);
01089   }
01090   else
01091   {
01092     MovingImageChanged();
01093   }
01094 }
01095 
01096 void QmitkRigidRegistrationView::MovingImageChanged()
01097 {
01098   if (dynamic_cast<mitk::Image*>(m_MovingNode->GetData()))
01099   {
01100     m_Controls.m_XTransSlider->setValue(0);
01101     m_Controls.m_YTransSlider->setValue(0);
01102     m_Controls.m_ZTransSlider->setValue(0);
01103     translationParams[0]=0;
01104     translationParams[1]=0;
01105     translationParams[2]=0;
01106     m_Controls.m_XRotSlider->setValue(0);
01107     m_Controls.m_YRotSlider->setValue(0);
01108     m_Controls.m_ZRotSlider->setValue(0);
01109     rotationParams[0]=0;
01110     rotationParams[1]=0;
01111     rotationParams[2]=0;
01112     m_Controls.m_XScaleSlider->setValue(0);
01113     m_Controls.m_YScaleSlider->setValue(0);
01114     m_Controls.m_ZScaleSlider->setValue(0);
01115     scalingParams[0]=0;
01116     scalingParams[1]=0;
01117     scalingParams[2]=0;
01118     m_MovingDimension = dynamic_cast<mitk::Image*>(m_MovingNode->GetData())->GetDimension();
01119     m_Controls.qmitkRigidRegistrationSelector1->SetMovingDimension(m_MovingDimension);
01120     m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
01121     this->CheckCalculateEnabled();
01122   }
01123 }
01124 
01125 void QmitkRigidRegistrationView::Calculate()
01126 {
01127   m_Controls.qmitkRigidRegistrationSelector1->SetFixedNode(m_FixedNode);
01128   m_Controls.qmitkRigidRegistrationSelector1->SetMovingNode(m_MovingNode);
01129   if (m_FixedMaskNode.IsNotNull() && m_Controls.m_UseFixedImageMask->isChecked())
01130   {
01131     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(m_FixedMaskNode);
01132   }
01133   else
01134   {
01135     m_Controls.qmitkRigidRegistrationSelector1->SetFixedMaskNode(NULL);
01136   }
01137   if (m_MovingMaskNode.IsNotNull() && m_Controls.m_UseMovingImageMask->isChecked())
01138   {
01139     m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(m_MovingMaskNode);
01140   }
01141   else
01142   {
01143     m_Controls.qmitkRigidRegistrationSelector1->SetMovingMaskNode(NULL);
01144   }
01145   m_Controls.frame_2->setEnabled(false);
01146   m_Controls.frame_3->setEnabled(false);
01147   m_Controls.m_CalculateTransformation->setEnabled(false);
01148   m_Controls.m_StopOptimization->setEnabled(true);
01149   m_Controls.qmitkRigidRegistrationSelector1->CalculateTransformation(((QmitkSliderNavigatorWidget*)m_Controls.timeSlider)->GetPos());
01150   m_Controls.m_StopOptimization->setEnabled(false);
01151   m_Controls.frame_2->setEnabled(true);
01152   m_Controls.frame_3->setEnabled(true);
01153   m_Controls.m_CalculateTransformation->setEnabled(true);
01154   m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(false);
01155 }
01156 
01157 void QmitkRigidRegistrationView::SetOptimizerValue( double value )
01158 {
01159   m_Controls.m_OptimizerValueLCD->display(value);
01160 }
01161 
01162 void QmitkRigidRegistrationView::StopOptimizationClicked()
01163 {
01164   m_Controls.qmitkRigidRegistrationSelector1->StopOptimization(true);
01165 }
01166 
01167 void QmitkRigidRegistrationView::UpdateTimestep()
01168 {
01169   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
01170 }
01171 
01172 void QmitkRigidRegistrationView::ShowManualRegistrationFrame(bool show)
01173 {
01174   if (show)
01175   {
01176     m_Controls.m_ManualFrame->show();
01177   }
01178   else
01179   {
01180     m_Controls.m_ManualFrame->hide();
01181   }
01182 }
01183 
01184 void QmitkRigidRegistrationView::SetImagesVisible(berry::ISelection::ConstPointer /*selection*/)
01185 {
01186   if (this->m_CurrentSelection->Size() == 0)
01187   {
01188     // show all images
01189     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
01190     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
01191       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
01192     {
01193       if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
01194       {
01195         nodeIt->Value()->SetVisibility(true);
01196       }
01197     }
01198   }
01199   else
01200   {
01201     // hide all images
01202     mitk::DataStorage::SetOfObjects::ConstPointer setOfObjects = this->GetDataStorage()->GetAll();
01203     for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = setOfObjects->Begin()
01204       ; nodeIt != setOfObjects->End(); ++nodeIt)  // for each node
01205     {
01206       if ( (nodeIt->Value().IsNotNull()) && (nodeIt->Value()->GetProperty("visible")) && dynamic_cast<mitk::Geometry2DData*>(nodeIt->Value()->GetData())==NULL)
01207       {
01208         nodeIt->Value()->SetVisibility(false);
01209       }
01210     }
01211   }
01212 }
01213 
01214 void QmitkRigidRegistrationView::CheckForMaskImages()
01215 {
01216   if (m_FixedMaskNode.IsNotNull())
01217   {
01218     m_Controls.m_UseFixedImageMask->show();
01219   }
01220   else
01221   {
01222     m_Controls.m_UseFixedImageMask->hide();
01223   }
01224   if (m_MovingMaskNode.IsNotNull())
01225   {
01226     m_Controls.m_UseMovingImageMask->show();
01227   }
01228   else
01229   {
01230     m_Controls.m_UseMovingImageMask->hide();
01231   }
01232 }
01233 
01234 void QmitkRigidRegistrationView::UseFixedMaskImageChecked(bool checked)
01235 {
01236   if (checked)
01237   {
01238     m_FixedMaskNode->SetVisibility(true);
01239   }
01240   else
01241   {
01242     m_FixedMaskNode->SetVisibility(false);
01243   }
01244 }
01245 
01246 void QmitkRigidRegistrationView::UseMovingMaskImageChecked(bool checked)
01247 {
01248   if (checked)
01249   {
01250     m_MovingMaskNode->SetVisibility(true);
01251   }
01252   else
01253   {
01254     m_MovingMaskNode->SetVisibility(false);
01255   }
01256 }
01257 
01258 void QmitkRigidRegistrationView::TabChanged(int index)
01259 {
01260   if (index == 0)
01261   {
01262     m_Controls.frame->hide();
01263   }
01264   else
01265   {
01266     m_Controls.frame->show();
01267   }
01268 }
01269 
01270 void QmitkRigidRegistrationView::SwitchImages()
01271 {
01272   mitk::DataNode::Pointer newMoving = m_FixedNode;
01273   mitk::DataNode::Pointer newFixed = m_MovingNode;
01274   this->FixedSelected(newFixed);
01275   this->MovingSelected(newMoving);
01276 }