mitk: QmitkQBallReconstructionView.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Module:    $RCSfile$
00005 Language:  C++
00006 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
00007 Version:   $Revision: 17495 $ 
00008  
00009 Copyright (c) German Cancer Research Center, Division of Medical and
00010 Biological Informatics. All rights reserved.
00011 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00012 
00013 This software is distributed WITHOUT ANY WARRANTY; without even
00014 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00015 PURPOSE.  See the above copyright notices for more information.
00016 
00017 =========================================================================*/
00018 
00019 //#define MBILOG_ENABLE_DEBUG
00020 
00021 #include "QmitkQBallReconstructionView.h"
00022 #include "mitkDiffusionImagingConfigure.h"
00023 
00024 // qt includes
00025 #include <QMessageBox>
00026 
00027 // itk includes
00028 #include "itkTimeProbe.h"
00029 
00030 // mitk includes
00031 #include "mitkProgressBar.h"
00032 #include "mitkStatusBar.h"
00033 
00034 #include "mitkNodePredicateDataType.h"
00035 #include "QmitkDataStorageComboBox.h"
00036 #include "QmitkStdMultiWidget.h"
00037 
00038 #include "itkDiffusionQballReconstructionImageFilter.h"
00039 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
00040 #include "itkVectorContainer.h"
00041 
00042 #include "mitkQBallImage.h"
00043 #include "mitkProperties.h"
00044 #include "mitkVtkResliceInterpolationProperty.h"
00045 #include "mitkLookupTable.h"
00046 #include "mitkLookupTableProperty.h"
00047 #include "mitkTransferFunction.h"
00048 #include "mitkTransferFunctionProperty.h"
00049 #include "mitkDataNodeObject.h"
00050 #include "mitkOdfNormalizationMethodProperty.h"
00051 #include "mitkOdfScaleByProperty.h"
00052 
00053 #include "berryIStructuredSelection.h"
00054 #include "berryIWorkbenchWindow.h"
00055 #include "berryISelectionService.h"
00056 
00057 const std::string QmitkQBallReconstructionView::VIEW_ID = 
00058   "org.mitk.views.qballreconstruction";
00059 
00060 #define DI_INFO MITK_INFO("DiffusionImaging")
00061 
00062 
00063 typedef float TTensorPixelType;
00064 
00065 const int QmitkQBallReconstructionView::nrconvkernels = 252;
00066 
00067 using namespace berry;
00068 
00069 struct QbrSelListener : ISelectionListener
00070 {
00071 
00072   berryObjectMacro(QbrSelListener);
00073 
00074   QbrSelListener(QmitkQBallReconstructionView* view)
00075   {
00076     m_View = view;
00077   }
00078 
00079   void DoSelectionChanged(ISelection::ConstPointer selection)
00080   {
00081     // save current selection in member variable
00082     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
00083 
00084     // do something with the selected items
00085     if(m_View->m_CurrentSelection)
00086     {
00087       bool foundDwiVolume = false;
00088 
00089       // iterate selection
00090       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
00091         i != m_View->m_CurrentSelection->End(); ++i)
00092       {
00093 
00094         // extract datatree node
00095         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00096         {
00097           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00098           
00099           // only look at interesting types
00100           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00101           {
00102             foundDwiVolume = true;
00103           }
00104         }
00105       }
00106 
00107       m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
00108     }
00109   }
00110 
00111   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
00112   {
00113     // check, if selection comes from datamanager
00114     if (part)
00115     {
00116       QString partname(part->GetPartName().c_str());
00117       if(partname.compare("Datamanager")==0)
00118       {
00119 
00120         // apply selection
00121         DoSelectionChanged(selection);
00122 
00123       }
00124     }
00125   }
00126 
00127   QmitkQBallReconstructionView* m_View;
00128 };
00129 
00130 QmitkQBallReconstructionView::QmitkQBallReconstructionView()
00131 : QmitkFunctionality(),
00132   m_Controls(NULL),
00133   m_MultiWidget(NULL)
00134 {
00135 }
00136 
00137 //void QmitkQBallReconstructionView::OpactiyChanged(int value)
00138 //{
00139 //  if (m_CurrentSelection)
00140 //  {
00141 //    if (mitk::DataNodeObject::Pointer nodeObj = m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>())
00142 //    {
00143 //      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00144 //      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00145 //      {
00146 //        node->SetIntProperty("DisplayChannel", value);
00147 //        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00148 //      }
00149 //    }
00150 //  }
00151 //}
00152 //
00153 //void QmitkQBallReconstructionView::OpactiyActionChanged()
00154 //{
00155 //    if (m_CurrentSelection)
00156 //  {
00157 //    if (mitk::DataNodeObject::Pointer nodeObj = m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>())
00158 //    {
00159 //      mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00160 //      if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00161 //      {
00162 //        int displayChannel = 0.0;
00163 //        if(node->GetIntProperty("DisplayChannel", displayChannel))
00164 //        {
00165 //          m_OpacitySlider->setValue(displayChannel);
00166 //        }
00167 //      }
00168 //    }
00169 //  }
00170 //    
00171 //  MITK_INFO << "changed";
00172 //}
00173 
00174 QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
00175 {
00176   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00177 }
00178 
00179 void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
00180 {
00181   if (!m_Controls)
00182   {
00183     // create GUI widgets
00184     m_Controls = new Ui::QmitkQBallReconstructionViewControls;
00185     m_Controls->setupUi(parent);
00186     this->CreateConnections();
00187 
00188     QStringList items;
00189     items << "2" << "4" << "6" << "8";
00190     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
00191     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
00192     m_Controls->m_Description->setText("Spherical harmonics recon. (Desoteaux2007)");
00193 
00194     m_Controls->m_QBallReconstructionNumberThreadsSpinbox->setValue(8);
00195 
00196 #ifndef DIFFUSION_IMAGING_EXTENDED
00197     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
00198 #endif
00199 
00200     AdvancedCheckboxClicked();
00201     // define data type for combobox
00202     //m_Controls->m_ImageSelector->SetDataStorage( this->GetDefaultDataStorage() );
00203     //m_Controls->m_ImageSelector->SetPredicate( mitk::NodePredicateDataType::New("DiffusionImage") );
00204   }
00205 
00206   m_SelListener = berry::ISelectionListener::Pointer(new QbrSelListener(this));
00207   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00208   berry::ISelection::ConstPointer sel(
00209     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00210   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00211   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
00212 }
00213 
00214 void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
00215 {
00216   m_MultiWidget = &stdMultiWidget;
00217 }
00218 
00219 void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
00220 {
00221   m_MultiWidget = NULL;
00222 }
00223 
00224 void QmitkQBallReconstructionView::CreateConnections()
00225 {
00226   if ( m_Controls )
00227   {
00228     connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
00229     connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
00230     connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
00231 
00232   }
00233 }
00234 
00235 void QmitkQBallReconstructionView::Activated()
00236 {
00237   QmitkFunctionality::Activated();
00238 
00239   berry::ISelection::ConstPointer sel(
00240     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00241   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00242   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
00243 }
00244 
00245 void QmitkQBallReconstructionView::Deactivated()
00246 {
00247   QmitkFunctionality::Deactivated();
00248 }
00249 
00250 void QmitkQBallReconstructionView::ReconstructStandard()
00251 {
00252 
00253   int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
00254 
00255 #ifndef DIFFUSION_IMAGING_EXTENDED
00256     if(index>=3)
00257     {
00258       index = index + 1;
00259     }
00260 #endif
00261 
00262   switch(index)
00263   {
00264   case 0:
00265     {
00266       // Numerical
00267       Reconstruct(0,0);
00268       break;
00269     }
00270   case 1:
00271     {
00272       // Standard
00273       Reconstruct(1,0);
00274       break;
00275     }
00276   case 2:
00277     {
00278       // Solid Angle
00279       Reconstruct(1,6);
00280       break;
00281     }
00282   case 3:
00283     {
00284       // Constrained Solid Angle
00285       Reconstruct(1,7);
00286       break;
00287     }
00288   case 4:
00289     {
00290       // ADC
00291       Reconstruct(1,4);
00292       break;
00293     }
00294   case 5:
00295     {
00296       // Raw Signal
00297       Reconstruct(1,5);
00298       break;
00299     }
00300   }
00301 }
00302 
00303 void QmitkQBallReconstructionView::MethodChoosen(int method)
00304 {
00305   switch(method)
00306   {
00307   case 0:
00308     m_Controls->m_Description->setText("Numerical recon. (Tuch2004)");
00309     break;
00310   case 1:
00311     m_Controls->m_Description->setText("Spherical harmonics recon. (Desoteaux2007)");
00312     break;
00313   case 2:
00314     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj2009)");
00315     break;
00316   case 3:
00317     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh2009)");
00318     break;
00319   case 4:
00320     m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
00321     break;
00322   case 5:
00323     m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
00324     break;
00325   }
00326 }
00327 
00328 
00329 
00330 void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
00331 {
00332   bool check = m_Controls->
00333     m_AdvancedCheckbox->isChecked();
00334   
00335   m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
00336   m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
00337   m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
00338   m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
00339  
00340   m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
00341   m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
00342   m_Controls->m_OutputB0Image->setVisible(check);
00343   m_Controls->m_QBallReconstructionNumberThreadsLabel_2->setVisible(check);
00344   m_Controls->m_QBallReconstructionNumberThreadsSpinbox->setVisible(check);
00345   m_Controls->label_2->setVisible(check);
00346 
00347   //m_Controls->textLabel1_2->setVisible(check);
00348   //m_Controls->m_QBallReconstructionLambdaStepLineEdit->setVisible(check);
00349   //m_Controls->textLabel1_3->setVisible(check);
00350   
00351   m_Controls->frame_2->setVisible(check);
00352 }
00353 
00354 void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
00355 {
00356   if (m_CurrentSelection)
00357   {
00358     mitk::DataStorage::SetOfObjects::Pointer set =
00359       mitk::DataStorage::SetOfObjects::New();
00360 
00361     int at = 0;
00362     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin(); 
00363       i != m_CurrentSelection->End(); 
00364       ++i)
00365     {
00366 
00367       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00368       {
00369         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00370         if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00371         {
00372           set->InsertElement(at++, node);
00373         }
00374       }
00375     }
00376 
00377     if(method == 0)
00378     {
00379       NumericalQBallReconstruction(set, normalization);
00380     }
00381 
00382     if(method == 1)
00383     {
00384       AnalyticalQBallReconstruction(set, normalization);
00385     }
00386 
00387   }
00388 }
00389 
00390 void QmitkQBallReconstructionView::NumericalQBallReconstruction
00391   (mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization) 
00392 {
00393   try
00394   {
00395     itk::TimeProbe clock;
00396 
00397     int nrFiles = inImages->size();
00398     if (!nrFiles) return;
00399 
00400     QString status;
00401     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
00402 
00403     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() ); 
00404     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() ); 
00405 
00406     std::vector<mitk::DataNode::Pointer> nodes;
00407     while ( itemiter != itemiterend ) // for all items
00408     {
00409 
00410       mitk::DiffusionImage<DiffusionPixelType>* vols = 
00411         static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
00412         (*itemiter)->GetData());
00413       
00414       std::string nodename;
00415       (*itemiter)->GetStringProperty("name", nodename);
00416       ++itemiter;
00417 
00418       // QBALL RECONSTRUCTION
00419       clock.Start();
00420       MBI_INFO << "QBall reconstruction ";
00421       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
00422         "QBall reconstruction for %s", nodename.c_str()).toAscii());
00423 
00424       typedef itk::DiffusionQballReconstructionImageFilter
00425         <DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
00426         QballReconstructionImageFilterType;
00427       
00428       QballReconstructionImageFilterType::Pointer filter = 
00429         QballReconstructionImageFilterType::New();
00430       filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
00431       filter->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsSpinbox->value() );
00432       filter->SetBValue(vols->GetB_Value());  
00433       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->text().toFloat() );
00434 
00435       switch(normalization)
00436       {
00437       case 0:
00438         {
00439           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
00440           break;
00441         }
00442       case 1:
00443         {
00444           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
00445           break;
00446         }
00447       case 2:
00448         {
00449           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
00450           break;
00451         }
00452       case 3:
00453         {
00454           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
00455           break;
00456         }
00457       default:
00458         {
00459           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
00460         }
00461       }
00462 
00463       filter->Update();
00464       clock.Stop();
00465       MBI_DEBUG << "took " << clock.GetMeanTime() << "s." ;
00466 
00467       // ODFs TO DATATREE
00468       mitk::QBallImage::Pointer image = mitk::QBallImage::New();
00469       image->InitializeByItk( filter->GetOutput() );
00470       //image->SetImportVolume( filter->GetOutput()->GetBufferPointer(), 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory );
00471       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
00472       mitk::DataNode::Pointer node=mitk::DataNode::New();
00473       node->SetData( image );
00474       QString newname;
00475       newname = newname.append(nodename.c_str());
00476       newname = newname.append("_QN%1").arg(normalization);
00477       SetDefaultNodeProperties(node, newname.toStdString());
00478       nodes.push_back(node);
00479       
00480       // B-Zero TO DATATREE
00481       if(m_Controls->m_OutputB0Image->isChecked())
00482       {
00483         mitk::Image::Pointer image4 = mitk::Image::New();
00484         image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
00485         image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
00486         mitk::DataNode::Pointer node4=mitk::DataNode::New();
00487         node4->SetData( image4 );
00488         node4->SetProperty( "name", mitk::StringProperty::New(
00489           QString(nodename.c_str()).append("_b0").toStdString()) );
00490         nodes.push_back(node4);
00491       }
00492       mitk::ProgressBar::GetInstance()->Progress();
00493 
00494     }
00495 
00496     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
00497     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
00498       GetDefaultDataStorage()->Add(*nodeIt);
00499 
00500     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
00501     m_MultiWidget->RequestUpdate();
00502 
00503   }
00504   catch (itk::ExceptionObject &ex)
00505   {
00506     MBI_INFO << ex ;
00507     return ;
00508   }
00509 }
00510 
00511 void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
00512   mitk::DataStorage::SetOfObjects::Pointer inImages, 
00513   int normalization) 
00514 {
00515   try
00516   {
00517     itk::TimeProbe clock;
00518 
00519     int nrFiles = inImages->size();
00520     if (!nrFiles) return;
00521 
00522     std::vector<float> lambdas;
00523     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->text().toFloat();
00524     lambdas.push_back(minLambda);
00525     int nLambdas = lambdas.size();
00526    
00527 
00528     QString status;
00529     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
00530 
00531     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() ); 
00532     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() ); 
00533 
00534     std::vector<mitk::DataNode::Pointer>* nodes
00535       = new std::vector<mitk::DataNode::Pointer>();
00536     while ( itemiter != itemiterend ) // for all items
00537     {
00538 
00539       mitk::DiffusionImage<DiffusionPixelType>* vols = 
00540         static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
00541         (*itemiter)->GetData());
00542 
00543       std::string nodename;
00544       (*itemiter)->GetStringProperty("name",nodename);
00545       itemiter++;
00546 
00547       // QBALL RECONSTRUCTION
00548       clock.Start();
00549       MBI_INFO << "QBall reconstruction ";
00550       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
00551         "QBall reconstruction for %s", nodename.c_str()).toAscii());
00552 
00553       for(int i=0; i<nLambdas; i++)
00554       {
00555 
00556         float currentLambda = lambdas[i];
00557 
00558         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
00559         {
00560         case 0:
00561           {
00562             TemplatedAnalyticalQBallReconstruction<2>(vols, currentLambda, nodename, nodes, normalization);
00563             break;
00564           }
00565         case 1:
00566           {
00567             TemplatedAnalyticalQBallReconstruction<4>(vols, currentLambda, nodename, nodes, normalization);
00568             break;
00569           }
00570         case 2:
00571           {
00572             TemplatedAnalyticalQBallReconstruction<6>(vols, currentLambda, nodename, nodes, normalization);
00573             break;
00574           }
00575         case 3:
00576           {
00577             TemplatedAnalyticalQBallReconstruction<8>(vols, currentLambda, nodename, nodes, normalization);
00578             break;
00579           }
00580         }
00581 
00582         clock.Stop();
00583         MBI_DEBUG << "took " << clock.GetMeanTime() << "s." ;
00584         mitk::ProgressBar::GetInstance()->Progress();
00585 
00586       }
00587     }
00588 
00589     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
00590     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
00591       GetDefaultDataStorage()->Add(*nodeIt);
00592 
00593     m_MultiWidget->RequestUpdate();
00594 
00595     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toAscii());
00596 
00597   }
00598   catch (itk::ExceptionObject &ex)
00599   {
00600     MBI_INFO << ex ;
00601     return ;
00602   }
00603 }
00604 
00605 template<int L>
00606 void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(
00607   mitk::DiffusionImage<DiffusionPixelType>* vols, float lambda,
00608   std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, 
00609   int normalization) 
00610 {
00611   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
00612     <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
00613   typename FilterType::Pointer filter = FilterType::New();
00614   filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
00615   filter->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsSpinbox->value() );
00616   filter->SetBValue(vols->GetB_Value());  
00617   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->text().toFloat() );
00618   filter->SetLambda(lambda);
00619 
00620   switch(normalization)
00621   {
00622   case 0:
00623     {
00624       filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
00625       break;
00626     }
00627   case 1:
00628     {
00629       filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
00630       break;
00631     }            
00632   case 2:
00633     {
00634       filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
00635       break;
00636     }
00637   case 3:
00638     {
00639       filter->SetNormalizationMethod(FilterType::QBAR_NONE);
00640       break;
00641     }
00642   case 4:
00643     {
00644       filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
00645       break;
00646     }
00647   case 5:
00648     {
00649       filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
00650       break;
00651     }
00652   case 6:
00653     {
00654       filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
00655       break;
00656     }
00657   case 7:
00658     {
00659       filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
00660       break;
00661     }
00662   default:
00663     {
00664       filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
00665     }
00666   }
00667 
00668   filter->Update();
00669 
00670   // ODFs TO DATATREE
00671   mitk::QBallImage::Pointer image = mitk::QBallImage::New();
00672   image->InitializeByItk( filter->GetOutput() );
00673   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
00674   mitk::DataNode::Pointer node=mitk::DataNode::New();
00675   node->SetData( image );
00676   QString newname;
00677   newname = newname.append(nodename.c_str());
00678   newname = newname.append("_QA%1").arg(normalization);
00679   SetDefaultNodeProperties(node, newname.toStdString());
00680   nodes->push_back(node);
00681   
00682   // B-Zero TO DATATREE
00683   if(m_Controls->m_OutputB0Image->isChecked())
00684   {
00685     mitk::Image::Pointer image4 = mitk::Image::New();
00686     image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
00687     image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
00688     mitk::DataNode::Pointer node4=mitk::DataNode::New();
00689     node4->SetData( image4 );
00690     node4->SetProperty( "name", mitk::StringProperty::New(
00691       QString(nodename.c_str()).append("_b0").toStdString()) );
00692     nodes->push_back(node4);
00693   }  
00694 }
00695 
00696 
00697 
00698 void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
00699 {
00700   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
00701   node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
00702   node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
00703   node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
00704   node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
00705   node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
00706   node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
00707   node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
00708   node->SetProperty ("layer", mitk::IntProperty::New(100));
00709   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
00710   //node->SetProperty( "opacity", mitk::FloatProperty::New(1.0f) );
00711 
00712   node->SetProperty( "name", mitk::StringProperty::New(name) );
00713 
00714 }
00715 
00716 
00717   //node->SetProperty( "volumerendering", mitk::BoolProperty::New( false ) );
00718   //node->SetProperty( "use color", mitk::BoolProperty::New( true ) );
00719   //node->SetProperty( "texture interpolation", mitk::BoolProperty::New( true ) );
00720   //node->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
00721   //node->SetProperty( "layer", mitk::IntProperty::New(0));
00722   //node->SetProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
00723   //node->SetOpacity(1.0f);
00724   //node->SetColor(1.0,1.0,1.0);  
00725   //node->SetVisibility(true);
00726   //node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
00727 
00728   //mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
00729   //mitk::LevelWindow levelwindow;
00731   //levWinProp->SetLevelWindow( levelwindow );
00732   //node->GetPropertyList()->SetProperty( "levelwindow", levWinProp );
00733 
00735   //if(!node->GetProperty("LookupTable"))
00736   //{
00737   //  mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
00738   //  vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
00739   //  vtkLut->SetHueRange(0.6667, 0.0);
00740   //  vtkLut->SetTableRange(0.0, 20.0);
00741   //  vtkLut->Build();
00742   //  mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
00743   //  mitkLutProp->SetLookupTable(mitkLut);
00744   //  node->SetProperty( "LookupTable", mitkLutProp );
00745   //}
00746   //if(!node->GetProperty("binary"))
00747   //  node->SetProperty( "binary", mitk::BoolProperty::New( false ) );
00748 
00750   //mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
00751   //node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
00752 
00754   //mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
00755   //node->SetProperty( "name", nameProp );