mitk: QmitkPreprocessingView.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 "QmitkPreprocessingView.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 "itkVectorContainer.h"
00039 
00040 #include "mitkProperties.h"
00041 #include "mitkVtkResliceInterpolationProperty.h"
00042 #include "mitkLookupTable.h"
00043 #include "mitkLookupTableProperty.h"
00044 #include "mitkTransferFunction.h"
00045 #include "mitkTransferFunctionProperty.h"
00046 #include "mitkDataNodeObject.h"
00047 #include "mitkOdfNormalizationMethodProperty.h"
00048 #include "mitkOdfScaleByProperty.h"
00049 
00050 #include "itkB0ImageExtractionImageFilter.h"
00051 #include "itkBrainMaskExtractionImageFilter.h"
00052 #include "itkCastImageFilter.h"
00053 
00054 #include "berryIStructuredSelection.h"
00055 #include "berryIWorkbenchWindow.h"
00056 #include "berryISelectionService.h"
00057 
00058 const std::string QmitkPreprocessingView::VIEW_ID = 
00059 "org.mitk.views.preprocessing";
00060 
00061 #define DI_INFO MITK_INFO("DiffusionImaging")
00062 
00063 
00064 typedef float TTensorPixelType;
00065 
00066 using namespace berry;
00067 
00068 struct PrpSelListener : ISelectionListener
00069 {
00070 
00071   berryObjectMacro(PrpSelListener);
00072 
00073   PrpSelListener(QmitkPreprocessingView* view)
00074   {
00075     m_View = view;
00076   }
00077 
00078   void DoSelectionChanged(ISelection::ConstPointer selection)
00079   {
00080     // save current selection in member variable
00081     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
00082 
00083     // do something with the selected items
00084     if(m_View->m_CurrentSelection)
00085     {
00086       bool foundDwiVolume = false;
00087 
00088       // iterate selection
00089       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
00090         i != m_View->m_CurrentSelection->End(); ++i)
00091       {
00092 
00093         // extract datatree node
00094         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00095         {
00096           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00097 
00098           // only look at interesting types
00099           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00100           {
00101             foundDwiVolume = true;
00102           }
00103         }
00104       }
00105 
00106       m_View->m_Controls->m_ButtonBrainMask->setEnabled(foundDwiVolume);
00107       m_View->m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
00108       m_View->m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);      
00109     }
00110   }
00111 
00112   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
00113   {
00114     // check, if selection comes from datamanager
00115     if (part)
00116     {
00117       QString partname(part->GetPartName().c_str());
00118       if(partname.compare("Datamanager")==0)
00119       {
00120 
00121         // apply selection
00122         DoSelectionChanged(selection);
00123 
00124       }
00125     }
00126   }
00127 
00128   QmitkPreprocessingView* m_View;
00129 };
00130 
00131 QmitkPreprocessingView::QmitkPreprocessingView()
00132 : QmitkFunctionality(),
00133 m_Controls(NULL),
00134 m_MultiWidget(NULL)
00135 {
00136 }
00137 
00138 QmitkPreprocessingView::~QmitkPreprocessingView()
00139 {
00140   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00141 }
00142 
00143 void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
00144 {
00145   if (!m_Controls)
00146   {
00147     // create GUI widgets
00148     m_Controls = new Ui::QmitkPreprocessingViewControls;
00149     m_Controls->setupUi(parent);
00150     this->CreateConnections();
00151   }
00152 
00153   m_SelListener = berry::ISelectionListener::Pointer(new PrpSelListener(this));
00154   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00155   berry::ISelection::ConstPointer sel(
00156     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00157   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00158   m_SelListener.Cast<PrpSelListener>()->DoSelectionChanged(sel);
00159 }
00160 
00161 void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
00162 {
00163   m_MultiWidget = &stdMultiWidget;
00164 }
00165 
00166 void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
00167 {
00168   m_MultiWidget = NULL;
00169 }
00170 
00171 void QmitkPreprocessingView::CreateConnections()
00172 {
00173   if ( m_Controls )
00174   {
00175     connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
00176     connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
00177     connect( (QObject*)(m_Controls->m_ButtonBrainMask), SIGNAL(clicked()), this, SLOT(BrainMask()) );
00178 
00179   }
00180 }
00181 
00182 void QmitkPreprocessingView::Activated()
00183 {
00184   QmitkFunctionality::Activated();
00185 
00186   berry::ISelection::ConstPointer sel(
00187     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00188   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00189   m_SelListener.Cast<PrpSelListener>()->DoSelectionChanged(sel);
00190 }
00191 
00192 void QmitkPreprocessingView::Deactivated()
00193 {
00194   QmitkFunctionality::Deactivated();
00195 }
00196 
00197 
00198 void QmitkPreprocessingView::ExtractB0()
00199 {
00200 
00201   if (m_CurrentSelection)
00202   {
00203     mitk::DataStorage::SetOfObjects::Pointer set =
00204       mitk::DataStorage::SetOfObjects::New();
00205 
00206     int at = 0;
00207     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin(); 
00208       i != m_CurrentSelection->End(); 
00209       ++i)
00210     {
00211 
00212       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00213       {
00214         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00215         if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00216         {
00217           set->InsertElement(at++, node);
00218         }
00219       }
00220     }
00221 
00222     DoExtractB0(set);
00223 
00224   }
00225 }
00226 
00227 void QmitkPreprocessingView::DoExtractB0
00228 (mitk::DataStorage::SetOfObjects::Pointer inImages)
00229 {
00230   typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
00231   typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
00232 
00233   int nrFiles = inImages->size();
00234   if (!nrFiles) return;
00235 
00236   mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() ); 
00237   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() ); 
00238 
00239   std::vector<mitk::DataNode::Pointer> nodes;
00240   while ( itemiter != itemiterend ) // for all items
00241   {
00242 
00243     DiffusionImageType* vols = 
00244       static_cast<DiffusionImageType*>(
00245       (*itemiter)->GetData());
00246 
00247     std::string nodename;
00248     (*itemiter)->GetStringProperty("name", nodename);
00249 
00250     // Extract image using found index
00251     typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
00252     FilterType::Pointer filter = FilterType::New();
00253     filter->SetInput(vols->GetVectorImage());
00254     filter->SetDirections(vols->GetDirections());
00255     filter->Update();
00256 
00257     mitk::Image::Pointer mitkImage = mitk::Image::New();
00258     mitkImage->InitializeByItk( filter->GetOutput() );
00259     mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
00260     mitk::DataNode::Pointer node=mitk::DataNode::New();
00261     node->SetData( mitkImage );
00262     node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
00263 
00264     GetDefaultDataStorage()->Add(node);
00265 
00266     ++itemiter;
00267   }
00268 
00269 
00270 }
00271 
00272 void QmitkPreprocessingView::AverageGradients()
00273 {
00274 
00275   if (m_CurrentSelection)
00276   {
00277     mitk::DataStorage::SetOfObjects::Pointer set =
00278       mitk::DataStorage::SetOfObjects::New();
00279 
00280     int at = 0;
00281     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin(); 
00282       i != m_CurrentSelection->End(); 
00283       ++i)
00284     {
00285 
00286       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00287       {
00288         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00289         if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00290         {
00291           set->InsertElement(at++, node);
00292         }
00293       }
00294     }
00295 
00296     DoAverageGradients(set);
00297 
00298   }
00299 
00300 }
00301 
00302 void QmitkPreprocessingView::DoAverageGradients
00303 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
00304 {
00305   int nrFiles = inImages->size();
00306   if (!nrFiles) return;
00307 
00308   mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() ); 
00309   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() ); 
00310 
00311   std::vector<mitk::DataNode::Pointer> nodes;
00312   while ( itemiter != itemiterend ) // for all items
00313   {
00314 
00315     mitk::DiffusionImage<DiffusionPixelType>* vols = 
00316       static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
00317       (*itemiter)->GetData());
00318 
00319     vols->AverageRedundantGradients(m_Controls->m_Blur->value());
00320 
00321     ++itemiter;
00322   }
00323 }
00324 
00325 void QmitkPreprocessingView::BrainMask()
00326 {
00327 
00328   if (m_CurrentSelection)
00329   {
00330     mitk::DataStorage::SetOfObjects::Pointer set =
00331       mitk::DataStorage::SetOfObjects::New();
00332 
00333     int at = 0;
00334     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin(); 
00335       i != m_CurrentSelection->End(); 
00336       ++i)
00337     {
00338 
00339       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00340       {
00341         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00342         if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00343         {
00344           set->InsertElement(at++, node);
00345         }
00346       }
00347     }
00348 
00349     DoBrainMask(set);
00350 
00351   }
00352 
00353 }
00354 
00355 void QmitkPreprocessingView::DoBrainMask
00356 (mitk::DataStorage::SetOfObjects::Pointer inImages) 
00357 {
00358   int nrFiles = inImages->size();
00359   if (!nrFiles) return;
00360 
00361   mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() ); 
00362   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() ); 
00363 
00364   std::vector<mitk::DataNode::Pointer> nodes;
00365   while ( itemiter != itemiterend ) // for all items
00366   {
00367 
00368     mitk::DiffusionImage<DiffusionPixelType>* vols = 
00369       static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
00370       (*itemiter)->GetData());
00371 
00372     std::string nodename;
00373     (*itemiter)->GetStringProperty("name", nodename);
00374 
00375     // Extract image using found index
00376     typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
00377     FilterType::Pointer filter = FilterType::New();
00378     filter->SetInput(vols->GetVectorImage());
00379     filter->SetDirections(vols->GetDirections());
00380 
00381     typedef itk::CastImageFilter<itk::Image<short,3>, itk::Image<unsigned short,3> > CastFilterType;
00382     CastFilterType::Pointer castfilter = CastFilterType::New();
00383     castfilter->SetInput(filter->GetOutput());
00384     
00385     typedef itk::BrainMaskExtractionImageFilter<unsigned char> MaskFilterType;
00386     MaskFilterType::Pointer maskfilter = MaskFilterType::New();
00387     maskfilter->SetInput(castfilter->GetOutput());
00388     maskfilter->Update();
00389 
00390     mitk::Image::Pointer mitkImage = mitk::Image::New();
00391     mitkImage->InitializeByItk( maskfilter->GetOutput() );
00392     mitkImage->SetVolume( maskfilter->GetOutput()->GetBufferPointer() );
00393     mitk::DataNode::Pointer node=mitk::DataNode::New();
00394     node->SetData( mitkImage );
00395     node->SetProperty( "name", mitk::StringProperty::New(nodename + "_Mask"));
00396 
00397     GetDefaultDataStorage()->Add(node);
00398 
00399     ++itemiter;
00400   }
00401 }