mitk: QmitkTbssView.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 #include "QmitkTbssView.h"
00020 #include "mitkDiffusionImagingConfigure.h"
00021 
00022 #include "mitkDataNodeObject.h"
00023 
00024 #include "berryIWorkbenchWindow.h"
00025 #include "berryIWorkbenchPage.h"
00026 #include "berryISelectionService.h"
00027 #include "berryConstants.h"
00028 #include "berryPlatformUI.h"
00029 
00030 #include <itkNiftiImageIO.h>
00031 #include <itkImageFileReader.h>
00032 
00033 #include <iostream>
00034 #include <fstream>
00035 
00036 
00037 const std::string QmitkTbssView::VIEW_ID = 
00038   "org.mitk.views.tbss";
00039 
00040 using namespace berry;
00041 
00042 
00043 
00044 
00045 struct TbSelListener : ISelectionListener
00046 {
00047 
00048   berryObjectMacro(TrSelListener);
00049 
00050   TbSelListener(QmitkTbssView* view)
00051   {
00052     m_View = view;
00053   }
00054 
00055   void DoSelectionChanged(ISelection::ConstPointer selection)
00056   {
00057 //    if(!m_View->IsVisible())
00058 //      return;
00059     // save current selection in member variable
00060     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
00061     
00062     // Disable the m_OutputValues button
00063     m_View->m_Controls->m_OutputValues->setEnabled(false);
00064 
00065     // do something with the selected items
00066     if(m_View->m_CurrentSelection)
00067     {
00068 
00069       if(m_View->m_CurrentSelection->Size() == 2)
00070       {
00071         m_View->m_Controls->m_StatusLabel->hide();
00072         bool foundSkeleton = false;
00073         bool foundRoi = false;
00074         
00075         mitk::DataNode::Pointer skeletonNode;
00076         mitk::DataNode::Pointer roiNode;
00077 
00078 
00079 
00080         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
00081           i != m_View->m_CurrentSelection->End(); ++i)
00082         {
00083           // extract datatree node
00084           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00085           {
00086             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00087             
00088             if(QString("Image").compare(node->GetData()->GetNameOfClass())== 0)
00089             {
00090               // Find 4D image (3d skeleton + user ID)
00091               if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
00092               {
00093                 m_View->SkeletonSelected(node);
00094                 foundSkeleton = true;
00095               }
00096 
00097               // The ROI
00098               else if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 3)
00099               {
00100                 m_View->RoiSelected(node);
00101                 foundRoi = true;
00102               }
00103             }
00104           }
00105         }
00106 
00107 
00108         if(foundSkeleton && foundRoi)
00109         {
00110           m_View->m_Controls->m_OutputValues->setEnabled(true);
00111         }
00112         else
00113         {          
00114            m_View->m_Controls->m_StatusLabel->show();
00115           m_View->m_Controls->m_RoiNameLabel->setText(QString::fromStdString(""));
00116           m_View->m_Controls->m_SkeletonNameLabel->setText(QString::fromStdString(""));
00117         }
00118 
00119 
00120       }
00121 
00122       else if(m_View->m_CurrentSelection->Size() == 1)
00123       {
00124               
00125         mitk::DataNode::Pointer skeletonNode;
00126         
00127         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
00128           i != m_View->m_CurrentSelection->End(); ++i)
00129         {
00130           // extract datatree node
00131           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00132           {
00133             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00134             
00135             if(QString("Image").compare(node->GetData()->GetNameOfClass())== 0)
00136             {
00137               // Find 4D image (3d skeleton + user ID)
00138               if (dynamic_cast<mitk::Image*>(node->GetData())->GetDimension() == 4)
00139               {
00140                 m_View->SkeletonSelected(node);                
00141               }
00142 
00143               
00144             }
00145           }
00146         }        
00147 
00148       }
00149 
00150       else{
00151         m_View->m_Controls->m_StatusLabel->show();
00152         m_View->m_Controls->m_RoiNameLabel->setText(QString::fromStdString(""));
00153         m_View->m_Controls->m_SkeletonNameLabel->setText(QString::fromStdString(""));
00154 
00155       }
00156 
00157 
00158       
00159       
00160       
00161     }
00162   }
00163 
00164   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
00165   {
00166     // check, if selection comes from datamanager
00167     if (part)
00168     {
00169       QString partname(part->GetPartName().c_str());
00170       if(partname.compare("Datamanager")==0)
00171       {
00172 
00173         // apply selection
00174         DoSelectionChanged(selection);
00175 
00176       }
00177     }
00178   }
00179 
00180   QmitkTbssView* m_View;
00181 };
00182 
00183 QmitkTbssView::QmitkTbssView()
00184 : QmitkFunctionality(),
00185   m_Controls(NULL),
00186   m_MultiWidget(NULL)
00187 {
00188 }
00189 
00190 QmitkTbssView::~QmitkTbssView()
00191 {
00192   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00193 }
00194 
00195 void QmitkTbssView::CreateQtPartControl(QWidget *parent)
00196 {
00197   if (!m_Controls)
00198   {
00199     // create GUI widgets
00200     m_Controls = new Ui::QmitkTbssViewControls;
00201     m_Controls->setupUi(parent);
00202     this->CreateConnections(); 
00203     
00204   }
00205 
00206   m_IsInitialized = false;
00207   m_SelListener = berry::ISelectionListener::Pointer(new TbSelListener(this));
00208   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00209   berry::ISelection::ConstPointer sel(
00210     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00211   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00212   m_SelListener.Cast<TbSelListener>()->DoSelectionChanged(sel);
00213 }
00214 
00215 void QmitkTbssView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
00216 {
00217   berry::ISelection::ConstPointer sel(
00218     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00219   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00220   m_SelListener.Cast<TbSelListener>()->DoSelectionChanged(sel);
00221   m_MultiWidget = &stdMultiWidget;
00222 }
00223 
00224 void QmitkTbssView::StdMultiWidgetNotAvailable()
00225 {
00226   m_MultiWidget = NULL;
00227 }
00228 
00229 void QmitkTbssView::CreateConnections()
00230 {
00231   if ( m_Controls )
00232   {
00233     connect( (QObject*)(m_Controls->m_OutputValues), SIGNAL(clicked()), this, SLOT(OutputValues()) );
00234     connect( (QObject*)(m_Controls->m_OutputPoints), SIGNAL(clicked()), this, SLOT(OutputUnconnectedPointValues()) );
00235   }
00236 }
00237 
00238 void QmitkTbssView::Activated()
00239 {
00240   QmitkFunctionality::Activated();
00241 }
00242 
00243 void QmitkTbssView::Deactivated()
00244 {
00245   QmitkFunctionality::Deactivated();
00246 }
00247 
00248 void QmitkTbssView::SkeletonSelected(mitk::DataNode::Pointer skeletonNode)
00249 {
00250   m_SkeletonNode = skeletonNode; 
00251   m_SkeletonNode->SetVisibility(true);
00252   m_Controls->m_SkeletonNameLabel->setText(QString::fromStdString(m_SkeletonNode->GetName()));  
00253 }
00254 
00255 void QmitkTbssView::RoiSelected(mitk::DataNode::Pointer roiNode)
00256 {
00257   m_RoiNode = roiNode; 
00258   m_RoiNode->SetVisibility(true);
00259   m_Controls->m_RoiNameLabel->setText(QString::fromStdString(m_RoiNode->GetName()));
00260 }
00261 
00262 void QmitkTbssView::OutputUnconnectedPointValues()
00263 {
00264   if(m_SkeletonNode.IsNull())
00265   {
00266     return;
00267   }
00268 
00269   //read roi
00270   /*mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( m_RoiNode->GetData() ); 
00271   RoiImageType::Pointer roi = RoiImageType::New();
00272   mitk::CastToItkImage(image, roi);*/
00273   
00274    //read the 4D skeleton
00275   mitk::Image::Pointer image2 = dynamic_cast<mitk::Image*>( m_SkeletonNode->GetData() ); 
00276   AllSkeletonType::Pointer skeleton = AllSkeletonType::New();  
00277   mitk::CastToItkImage(image2, skeleton);
00278 
00279  // RoiImageType::SizeType roiSize = roi->GetLargestPossibleRegion().GetSize();
00280   AllSkeletonType::SizeType skeletonSize = skeleton->GetLargestPossibleRegion().GetSize();
00281 
00282 
00283 
00284   AllSkeletonType::IndexType indices[3];
00285   indices[2][0] = 98; indices[2][1] = 126; indices[2][2] = 105;
00286   indices[3][0] = 101; indices[3][1] = 98; indices[3][2] = 104;
00287   indices[4][0] = 101; indices[4][1] = 76; indices[4][2] = 92;
00288 
00289   // output file
00290   std::string filename = "G://home//vanbrugg//spie2011//CingulumHealthy.csv";
00291   std::ofstream f;
00292   f.open(filename.c_str());
00293 
00294   for (int s=0; s<skeletonSize[3]; s++)
00295   {
00296     
00297     for(int t=0; t<3; t++)
00298     {
00299       indices[t][3] = s;     
00300       f << skeleton->GetPixel(indices[t]) << ",";
00301     }
00302 
00303     f << std::endl;
00304   }
00305   f.close();
00306 
00307   //for(int x=0; x<roiSize[0]; x++)
00308   //{
00309   //  for(int y=0; y<roiSize[1]; y++)
00310   //  {
00311   //    for(int z=0; z<roiSize[2]; z++)
00312   //    {
00313   //      RoiImageType::IndexType index;
00314   //      index[0] = x;
00315   //      index[1] = y;
00316   //      index[2] = z;
00317   //      if (roi->GetPixel(index) != 0)
00318   //      {
00319   //        // Output the values of this point for all subjects
00320   //        AllSkeletonType::IndexType skeletonIndex;
00321   //        skeletonIndex[0] = index[0];
00322   //        skeletonIndex[1] = index[1];
00323   //        skeletonIndex[2] = index[2];
00324 
00325   //       
00326 
00327   //        for(int t=0; t<skeletonSize[3]; t++)
00328   //        {
00329   //          if(index[0] == 90 && index[1] == 98 && index[2] == 95)
00330   //          {
00331   //            std::cout << "the empty voxel" << std::endl;
00332   //          }
00333   //          skeletonIndex[3] = t;
00334   //          std::cout << skeleton->GetPixel(skeletonIndex) << std::endl;
00335   //        }
00336 
00337   //        std::cout << " ";
00338   //      }
00339   //    }
00340   //  }
00341   //}
00342 
00343 }
00344 
00345 void QmitkTbssView::OutputValues()
00346 {
00347 
00348   if(m_SkeletonNode.IsNull() || m_RoiNode.IsNull())
00349   {
00350     return;
00351   }
00352 
00353 
00354   //read roi
00355   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( m_RoiNode->GetData() ); 
00356   RoiImageType::Pointer roi = RoiImageType::New();
00357   mitk::CastToItkImage(image, roi);
00358 
00359   //read the 4D skeleton
00360   mitk::Image::Pointer image2 = dynamic_cast<mitk::Image*>( m_SkeletonNode->GetData() ); 
00361   AllSkeletonType::Pointer skeleton = AllSkeletonType::New();  
00362   mitk::CastToItkImage(image2, skeleton);
00363 
00364   RoiImageType::SizeType roiSize = roi->GetLargestPossibleRegion().GetSize();
00365   AllSkeletonType::SizeType skeletonSize = skeleton->GetLargestPossibleRegion().GetSize();
00366 
00367   std::vector<RoiImageType::IndexType> indices = SortPoints(roi);
00368 
00369 
00370   //For every subject (4th axis of the 4D volume) output the tract of interest and write results to file
00371   std::string filename = "G://home//vanbrugg//spie2011//paraHipLeftHealthy.csv";
00372   std::ofstream f;
00373   f.open(filename.c_str());
00374   
00375 
00376   for (int s=0; s<skeletonSize[3]; s++)
00377   {
00378     std::vector<RoiImageType::IndexType>::iterator it = indices.begin();    
00379     while(it != indices.end())
00380     {
00381       RoiImageType::IndexType roiIndex = *it;
00382       AllSkeletonType::IndexType skeletonIndex;
00383       skeletonIndex[0] = roiIndex[0];
00384       skeletonIndex[1] = roiIndex[1];
00385       skeletonIndex[2] = roiIndex[2];
00386       skeletonIndex[3] = s;
00387 
00388       //std::cout << skeleton->GetPixel(skeletonIndex) << ",";
00389 
00390       f << skeleton->GetPixel(skeletonIndex) << ",";
00391      
00392 
00393       ++it;
00394     }
00395     f << std::endl;
00396   }
00397 
00398   f.close();
00399 
00400   //for(int x=0; x<roiSize[0]; x++)
00401   //{
00402   //  for(int y=0; y<roiSize[1]; y++)
00403   //  {
00404   //    for(int z=0; z<roiSize[2]; z++)
00405   //    {
00406   //      RoiImageType::IndexType index;
00407   //      index[0] = x;
00408   //      index[1] = y;
00409   //      index[2] = z;
00410   //      if (roi->GetPixel(index) != 0)
00411   //      {
00412   //        // Output the values of this point for all subjects
00413   //        AllSkeletonType::IndexType skeletonIndex;
00414   //        skeletonIndex[0] = index[0];
00415   //        skeletonIndex[1] = index[1];
00416   //        skeletonIndex[2] = index[2];
00417 
00418   //       
00419 
00420   //        for(int t=0; t<skeletonSize[3]; t++)
00421   //        {
00422   //          if(index[0] == 90 && index[1] == 98 && index[2] == 95)
00423   //          {
00424   //            std::cout << "the empty voxel" << std::endl;
00425   //          }
00426   //          skeletonIndex[3] = t;
00427   //          std::cout << skeleton->GetPixel(skeletonIndex) << std::endl;
00428   //        }
00429 
00430   //        std::cout << " ";
00431   //      }
00432   //    }
00433   //  }
00434   //}
00435   
00436    
00437   
00438 }
00439 
00440 std::vector<RoiImageType::IndexType> QmitkTbssView::SortPoints(RoiImageType::Pointer roi)
00441 {
00442   std::vector<RoiImageType::IndexType> indices;
00443   
00444   //set current point to be the start point. Hard coded for now, should be changed to function in general
00445   RoiImageType::IndexType currentPoint;
00446   //currentPoint[0] = 90; // For Corpus Callosum the constant index;
00447   //currentPoint[1] = 88;
00448   //currentPoint[2] = 82;
00449 
00450   //currentPoint[0] = 65; //standard for right parahippocampal white matter
00451   //currentPoint[1] = 108;
00452   //currentPoint[2] = 45;
00453 
00454   currentPoint[0] = 95; 
00455   currentPoint[1] = 166;
00456   currentPoint[2] = 78;
00457 
00458   bool ready = false;
00459   while(!ready)
00460   {
00461     indices.push_back(currentPoint);
00462     currentPoint = FindNextPoint(indices, currentPoint, roi, ready);
00463   }
00464 
00465   return indices;
00466 }
00467 
00468 bool QmitkTbssView::PointVisited(std::vector<RoiImageType::IndexType> points, RoiImageType::IndexType point)
00469 {
00470   bool ret = false;
00471   std::vector<RoiImageType::IndexType>::iterator it = points.begin();
00472   while(it != points.end())
00473   {
00474     RoiImageType::IndexType p = *it;
00475     if(p[0] == point[0] && p[1] == point[1] && p[2] == point[2])
00476     {
00477       ret = true;
00478     }
00479     ++it;
00480   }
00481 
00482   return ret;
00483 }
00484 
00485 RoiImageType::IndexType QmitkTbssView::FindNextPoint(std::vector<RoiImageType::IndexType> pointsVisited, 
00486                                                      RoiImageType::IndexType currentPoint, RoiImageType::Pointer roi, bool &ready)
00487 {  
00488 
00489   RoiImageType::IndexValueType dx[26] = {0, 0, 1, 1, 1, 0,-1,-1,-1,0,1,1, 1, 0,-1,-1,-1, 0, 1, 1, 1, 0,-1,-1,-1, 0};
00490   RoiImageType::IndexValueType dy[26] = {0, 1, 1, 0,-1,-1,-1, 0, 1,1,1,0,-1,-1,-1, 0, 1, 1, 1, 0,-1,-1,-1, 0, 1, 0};
00491   RoiImageType::IndexValueType dz[26] = {0, 0, 0, 0, 0, 0, 0, 0, 0,1,1,1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1,-1,-1,-1, 1};
00492 
00493   RoiImageType::IndexType newPoint;   
00494 
00495   for (int step=0; step<26; step++)
00496   {
00497     newPoint[0] = currentPoint[0] + dx[step];
00498     newPoint[1] = currentPoint[1] + dy[step];
00499     newPoint[2] = currentPoint[2] + dz[step];
00500 
00501     // Check if point is not yet visited
00502     if(!PointVisited(pointsVisited, newPoint))
00503     {
00504       if(roi->GetPixel(newPoint) == 1)
00505         return newPoint;
00506     }
00507   }
00508 
00509   // No points yet to be visited found so we are done searching
00510   ready = true;
00511   return currentPoint;
00512 
00513 }
00514 
00515