mitk: QmitkDiffusionDicomImportView.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 Copyright (c) German Cancer Research Center, Division of Medical and
00003 Biological Informatics. All rights reserved.
00004 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00005 
00006 This software is distributed WITHOUT ANY WARRANTY; without even
00007 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00008 PURPOSE.  See the above copyright notices for more information.
00009 
00010 =========================================================================*/
00011 
00012 #include "QmitkDiffusionDicomImportView.h"
00013 
00014 // qt includes
00015 #include <QFileDialog>
00016 
00017 // itk includes
00018 #include "itkTimeProbesCollectorBase.h"
00019 #include "itkGDCMSeriesFileNames.h"
00020 #include "itksys/SystemTools.hxx"
00021 
00022 // mitk includes
00023 #include "mitkProgressBar.h"
00024 #include "mitkStatusBar.h"
00025 #include "mitkProperties.h"
00026 #include "mitkRenderingManager.h"
00027 #include "mitkMemoryUtilities.h"
00028 
00029 // diffusion module includes
00030 #include "mitkDicomDiffusionImageHeaderReader.h"
00031 #include "mitkGroupDiffusionHeadersFilter.h"
00032 #include "mitkDicomDiffusionImageReader.h"
00033 #include "mitkDiffusionImage.h"
00034 #include "mitkNrrdDiffusionImageWriter.h"
00035 
00036 #if  GDCM_MAJOR_VERSION >= 2
00037 #define DGDCM2
00038 #endif
00039 
00040 #ifdef DGDCM2
00041 #include "gdcmDirectory.h"
00042 #include "gdcmScanner.h"
00043 #include "gdcmSorter.h"
00044 #include "gdcmIPPSorter.h"
00045 #include "gdcmAttribute.h"
00046 #include "gdcmVersion.h"
00047 #endif
00048 
00049 const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
00050 
00051 
00052 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
00053   : QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
00054   m_OutputFolderName(""), m_OutputFolderNameSet(false)
00055 {
00056 }
00057 
00058 QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
00059 {}
00060 
00061 void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
00062 {
00063   m_Parent = parent;
00064   if (m_Controls == NULL)
00065   {
00066     m_Controls = new Ui::QmitkDiffusionDicomImportControls;
00067     m_Controls->setupUi(parent);
00068     this->CreateConnections();
00069 
00070     m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(true);
00071     m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
00072 
00073 #ifdef DGDCM2
00074     m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(false);
00075 #endif
00076 
00077     AverageClicked();
00078   }
00079 }
00080 
00081 
00082 
00083 void QmitkDiffusionDicomImport::CreateConnections()
00084 {
00085   if ( m_Controls )
00086   {
00087     connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), 
00088              this, SLOT(DicomLoadAddFolderNames()) );
00089     connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), 
00090              this, SLOT(DicomLoadDeleteFolderNames()) );
00091     connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), 
00092              this, SLOT(DicomLoadStartLoad()) );
00093     connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()),
00094              this, SLOT(AverageClicked()) );
00095     connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()),
00096              this, SLOT(OutputSet()) );
00097     connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()),
00098              this, SLOT(OutputClear()) );
00099   }
00100 }
00101 
00102 
00103 void QmitkDiffusionDicomImport::OutputSet()
00104 {
00105   // SELECT FOLDER DIALOG
00106   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
00107   w->setFileMode( QFileDialog::Directory );
00108 
00109   // RETRIEVE SELECTION
00110   if ( w->exec() != QDialog::Accepted )
00111     return;
00112 
00113   m_OutputFolderName = w->selectedFiles()[0];
00114   m_OutputFolderNameSet = true;
00115   m_Controls->m_OutputLabel->setText(m_OutputFolderName);
00116 }
00117 
00118 void QmitkDiffusionDicomImport::OutputClear()
00119 {
00120   m_OutputFolderName = "";
00121   m_OutputFolderNameSet = false;
00122   m_Controls->m_OutputLabel->setText("... optional out-folder ...");
00123 }
00124 
00125 void QmitkDiffusionDicomImport::AverageClicked()
00126 {
00127   m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
00128 }
00129 
00130 void QmitkDiffusionDicomImport::Activated()
00131 {
00132   QmitkFunctionality::Activated();
00133 }
00134 
00135 void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames() 
00136 {
00137   m_Controls->listWidget->clear();
00138 }
00139 
00140 void QmitkDiffusionDicomImport::DicomLoadAddFolderNames() 
00141 {
00142   // SELECT FOLDER DIALOG
00143   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
00144   w->setFileMode( QFileDialog::Directory );
00145 
00146   // RETRIEVE SELECTION
00147   if ( w->exec() != QDialog::Accepted )
00148     return;
00149 
00150   m_Controls->listWidget->addItems(w->selectedFiles());
00151 }
00152 
00153 #ifdef DGDCM2
00154 bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
00155 {
00156   gdcm::Attribute<0x0020,0x000e> at1;
00157   at1.Set( ds1 );
00158   gdcm::Attribute<0x0020,0x000e> at2;
00159   at2.Set( ds2 );
00160   return at1 < at2;
00161 }
00162 
00163 bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
00164 {
00165   gdcm::Attribute<0x0020,0x0012> at1;
00166   at1.Set( ds1 );
00167   gdcm::Attribute<0x0020,0x0012> at2;
00168   at2.Set( ds2 );
00169   return at1 < at2;
00170 }
00171 
00172 bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
00173 {
00174   gdcm::Attribute<0x0018, 0x0024> at1;
00175   at1.Set( ds1 );
00176   gdcm::Attribute<0x0018, 0x0024> at2;
00177   at2.Set( ds2 );
00178 
00179   std::string str1 = at1.GetValue(0).Trim();
00180   std::string str2 = at2.GetValue(0).Trim();
00181   return std::lexicographical_compare(str1.begin(), str1.end(),
00182                                       str2.begin(), str2.end() );
00183 }
00184 #endif
00185 
00186 void QmitkDiffusionDicomImport::Status(QString status)
00187 {
00188   mitk::StatusBar::GetInstance()->DisplayText(status.toAscii());
00189   MITK_INFO << status.toStdString().c_str();
00190 }
00191 
00192 void QmitkDiffusionDicomImport::Status(std::string status)
00193 {
00194   mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
00195   MITK_INFO << status.c_str();
00196 }
00197 
00198 void QmitkDiffusionDicomImport::Status(const char* status)
00199 {
00200   mitk::StatusBar::GetInstance()->DisplayText(status);
00201   MITK_INFO << status;
00202 }
00203 
00204 void QmitkDiffusionDicomImport::Error(QString status)
00205 {
00206   mitk::StatusBar::GetInstance()->DisplayErrorText(status.toAscii());
00207   MITK_ERROR << status.toStdString().c_str();
00208 }
00209 
00210 void QmitkDiffusionDicomImport::Error(std::string status)
00211 {
00212   mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
00213   MITK_ERROR << status.c_str();
00214 }
00215 
00216 void QmitkDiffusionDicomImport::Error(const char* status)
00217 {
00218   mitk::StatusBar::GetInstance()->DisplayErrorText(status);
00219   MITK_ERROR << status;
00220 }
00221 
00222 void QmitkDiffusionDicomImport::PrintMemoryUsage()
00223 {
00224   size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
00225   size_t totalSize =  mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
00226   float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
00227   MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
00228 }
00229 
00230 std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
00231 {
00232   double val = size;
00233   std::string descriptor("B");
00234   if ( val >= 1000.0 )
00235   {
00236     val /= 1024.0;
00237     descriptor = "KB";
00238   }
00239   if ( val >= 1000.0 )
00240   {
00241     val /= 1024.0;
00242     descriptor = "MB";
00243   }
00244   if ( val >= 1000.0 )
00245   {
00246     val /= 1024.0;
00247     descriptor = "GB";
00248   }
00249   std::ostringstream str;
00250   str << std::fixed << std::setprecision(2) << val << " " << descriptor;
00251   return str.str();
00252 }
00253 
00254 std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
00255 {
00256   std::ostringstream str;
00257   str << std::fixed << std::setprecision(2) << val << " " << "%";
00258   return str.str();
00259 }
00260 
00261 std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
00262 {
00263   std::ostringstream str;
00264   str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
00265   return str.str();
00266 }
00267 
00268 void QmitkDiffusionDicomImport::DicomLoadStartLoad() 
00269 {
00270   itk::TimeProbesCollectorBase clock;
00271 
00272   try
00273   {
00274 
00275     int nrFolders = m_Controls->listWidget->count();
00276 
00277     if(!nrFolders)
00278     {
00279       Error(QString("No input folders were selected. ABORTING."));
00280       return;
00281     }
00282 
00283 #ifndef DGDCM2
00284     Status(QString("GDCM 1.x used for DICOM parsing and sorting!"));
00285 #else
00286     Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
00287 #endif
00288 
00289     PrintMemoryUsage();
00290     QString status;
00291     mitk::DataNode::Pointer node;
00292     mitk::ProgressBar::GetInstance()->AddStepsToDo(3*nrFolders);
00293 
00294     while(m_Controls->listWidget->count())
00295     {
00296 
00297       // RETREIVE FOLDERNAME
00298       QListWidgetItem * item  = m_Controls->listWidget->takeItem(0);
00299       QString folderName = item->text();
00300 
00301       // PARSING DIRECTORY
00302       PrintMemoryUsage();
00303       clock.Start(folderName.toAscii());
00304       std::vector<std::string> seriesUIDs(0);
00305       std::vector<std::vector<std::string> > seriesFilenames(0);
00306 #ifndef DGDCM2
00307       Status(QString("Parsing directory %1").arg(folderName));
00308       typedef itk::GDCMSeriesFileNames InputNamesType;
00309       InputNamesType::Pointer inputNames = InputNamesType::New();
00310 
00320 
00321       inputNames->SetRecursive(m_Controls->m_DicomLoadRecursiveCheckbox->isChecked());
00322       inputNames->SetUseSeriesDetails(true);
00323       inputNames->AddSeriesRestriction( "0020|0012" );
00324       inputNames->SetInputDirectory( folderName.toAscii() );
00325       mitk::ProgressBar::GetInstance()->Progress();
00326       seriesUIDs = inputNames->GetSeriesUIDs();
00327       unsigned int size = seriesUIDs.size();
00328       for ( unsigned int i = 0 ; i < size ; ++i )
00329       {
00330         seriesFilenames.push_back(inputNames->GetFileNames(seriesUIDs[i]));
00331       }
00332 #else
00333 
00334       Status("== Initial Directory Scan ==");
00335       gdcm::Directory d;
00336       d.Load( folderName.toStdString().c_str(), true ); // recursive !
00337       const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
00338       const unsigned int ntotalfiles = l1.size();
00339       Status(QString(" ... found %1 different files").arg(ntotalfiles));
00340 
00341       Status("Scanning Headers");
00342       gdcm::Scanner s;
00343       const gdcm::Tag t1(0x0020,0x000d); // Study Instance UID
00344       const gdcm::Tag t2(0x0020,0x000e); // Series Instance UID
00345       const gdcm::Tag t5(0x0028, 0x0010); // number rows
00346       const gdcm::Tag t6(0x0028, 0x0011); // number cols
00347       s.AddTag( t1 );
00348       s.AddTag( t2 );
00349       s.AddTag( t5 );
00350       s.AddTag( t6 );
00351 
00352       bool b = s.Scan( d.GetFilenames() );
00353       if( !b )
00354       {
00355         Error("Scanner failed");
00356         continue;
00357       }
00358 
00359       // Only get the DICOM files:
00360       gdcm::Directory::FilenamesType l2 = s.GetKeys();
00361       const int nfiles = l2.size();
00362       if(nfiles < 1)
00363       {
00364         Error("No DICOM files found");
00365         continue;
00366       }
00367       Status(QString(" ... successfully scanned %1 headers.").arg(nfiles));
00368 
00369       Status("Sorting");
00370 
00371       const gdcm::Scanner::ValuesType &values1 = s.GetValues(t1);
00372       int nvalues = values1.size();
00373       if(nvalues>1)
00374       {
00375         Error("Multiple studies found. Please limit to 1 study per folder");
00376         continue;
00377       }
00378 
00379       const gdcm::Scanner::ValuesType &values5 = s.GetValues(t5);
00380       const gdcm::Scanner::ValuesType &values6 = s.GetValues(t6);
00381       if(values5.size()>1 || values6.size()>1)
00382       {
00383         Error("Folder contains images of unequal dimensions that cannot be combined in one 3d volume. ABORTING.");
00384         continue;
00385       }
00386 
00387       const gdcm::Scanner::ValuesType &values2 = s.GetValues(t2);
00388       int nSeries = values2.size();
00389 
00390       gdcm::Directory::FilenamesType files;
00391       if(nSeries > 1)
00392       {
00393         gdcm::Sorter sorter;
00394         sorter.SetSortFunction( SortBySeriesUID );
00395         sorter.StableSort( l2 );
00396         files = sorter.GetFilenames();
00397       }
00398       else
00399       {
00400         files = l2;
00401       }
00402 
00403       unsigned int nTotalAcquis = 0;
00404 
00405       if(nfiles % nSeries != 0)
00406       {
00407         Error("Number of files in series not equal, ABORTING");
00408         continue;
00409       }
00410 
00411       int filesPerSeries = nfiles / nSeries;
00412 
00413       gdcm::Scanner::ValuesType::const_iterator it2 = values2.begin();
00414       for(int i=0; i<nSeries; i++)
00415       {
00416 
00417         gdcm::Directory::FilenamesType sub( files.begin() + i*filesPerSeries, files.begin() + (i+1)*filesPerSeries);
00418 
00419         gdcm::Scanner s;
00420         const gdcm::Tag t3(0x0020,0x0012);  // Acquisition ID
00421         const gdcm::Tag t4(0x0018, 0x0024); // Sequence Name (in case acquisitions are equal for all)
00422         //        const gdcm::Tag t5(0x20,0x32) );    // Image Position (Patient)
00423         s.AddTag(t3);
00424         s.AddTag(t4);
00425         //        s.AddTag(t5);
00426 
00427         bool b = s.Scan( sub );
00428         if( !b )
00429         {
00430           Error("Scanner failed");
00431           continue;
00432         }
00433 
00434         gdcm::Sorter subsorter;
00435         gdcm::Scanner::ValuesType::const_iterator it;
00436 
00437         const gdcm::Scanner::ValuesType &values3 = s.GetValues(t3);
00438         const gdcm::Scanner::ValuesType &values4 = s.GetValues(t4);;
00439         unsigned int nAcquis = values3.size();
00440 
00441         if(nAcquis != 1)
00442         {
00443           subsorter.SetSortFunction( SortByAcquisitionNumber );
00444           it = values3.begin();
00445         }
00446         else
00447         {
00448           nAcquis = values4.size();
00449           subsorter.SetSortFunction( SortBySeqName );
00450           it = values4.begin();
00451         }
00452         nTotalAcquis += nAcquis;
00453         subsorter.Sort( sub );
00454 
00455         if(filesPerSeries % nAcquis != 0)
00456         {
00457           Error("Number of files per acquisition not equal, ABORTING");
00458           continue;
00459         }
00460 
00461         int filesPerAcqu = filesPerSeries / nAcquis;
00462 
00463         gdcm::Directory::FilenamesType subfiles = subsorter.GetFilenames();
00464         for ( unsigned int j = 0 ; j < nAcquis ; ++j )
00465         {
00466           std::string identifier = "serie_" + *it2 + "_acquis_" + *it++;
00467 
00468           gdcm::IPPSorter ippsorter;
00469           gdcm::Directory::FilenamesType ipplist((j)*filesPerAcqu+subfiles.begin(),(j+1)*filesPerAcqu+subfiles.begin());
00470           ippsorter.SetComputeZSpacing( false );
00471           if( !ippsorter.Sort( ipplist ) )
00472           {
00473             Error(QString("Failed to sort acquisition %1, ABORTING").arg(identifier.c_str()));
00474             continue;
00475           }
00476           const std::vector<std::string> & list = ippsorter.GetFilenames();
00477           seriesFilenames.push_back(list);
00478           seriesUIDs.push_back(identifier.c_str());
00479         }
00480         ++it2;
00481       }
00482 
00483       if(nfiles % nTotalAcquis != 0)
00484       {
00485         Error("Number of files per acquisition differs between series, ABORTING");
00486         continue;
00487       }
00488 
00489       int slices = nfiles/nTotalAcquis;
00490       Status(QString("Series is composed of %1 different 3D volumes with %2 slices.").arg(nTotalAcquis).arg(slices));
00491 
00492 #endif
00493 
00494       // READING HEADER-INFOS
00495       PrintMemoryUsage();
00496       Status(QString("Reading Headers %1").arg(folderName));
00497 
00498       mitk::DicomDiffusionImageHeaderReader::Pointer headerReader;
00499       mitk::GroupDiffusionHeadersFilter::InputType inHeaders;
00500       unsigned int size2 = seriesUIDs.size();
00501       for ( unsigned int i = 0 ; i < size2 ; ++i )
00502       {
00503         Status(QString("Reading header image #%1/%2").arg(i+1).arg(size2));
00504         headerReader = mitk::DicomDiffusionImageHeaderReader::New();
00505         headerReader->SetSeriesDicomFilenames(seriesFilenames[i]);
00506         headerReader->Update();
00507         inHeaders.push_back(headerReader->GetOutput());
00508         //Status(std::endl;
00509       }
00510       mitk::ProgressBar::GetInstance()->Progress();
00511 
00512       //        // GROUP HEADERS
00513       //        mitk::GroupDiffusionHeadersFilter::Pointer grouper
00514       //            = mitk::GroupDiffusionHeadersFilter::New();
00515       //        mitk::GroupDiffusionHeadersFilter::OutputType outHeaders;
00516       //        grouper->SetInput(inHeaders);
00517       //        grouper->Update();
00518       //        outHeaders = grouper->GetOutput();
00519 
00520       // READ VOLUMES
00521       PrintMemoryUsage();
00522       Status(QString("Loading Volumes %1").arg(folderName));
00523       typedef short PixelValueType;
00524       typedef mitk::DicomDiffusionImageReader< PixelValueType, 3 > VolumesReader;
00525       VolumesReader::Pointer vReader = VolumesReader::New();
00526       VolumesReader::HeaderContainer hc = inHeaders;
00527 
00528       //        hc.insert(hc.end(), outHeaders[1].begin(), outHeaders[1].end() );
00529       //        hc.insert(hc.end(), outHeaders[2].begin(), outHeaders[2].end() );
00530       if(hc.size()>1)
00531       {
00532         vReader->SetHeaders(hc);
00533         vReader->Update();
00534         VolumesReader::OutputImageType::Pointer vecImage;
00535         vecImage = vReader->GetOutput();
00536         Status(QString("Volumes Loaded (%1)").arg(folderName));
00537 
00538         // CONSTRUCT CONTAINER WITH DIRECTIONS
00539         typedef vnl_vector_fixed< double, 3 >            GradientDirectionType;
00540         typedef itk::VectorContainer< unsigned int,
00541         GradientDirectionType >                  GradientDirectionContainerType;
00542         GradientDirectionContainerType::Pointer directions =
00543             GradientDirectionContainerType::New();
00544         std::vector<double> b_vals;
00545         double maxb = 0;
00546         for(unsigned int i=0; i<hc.size(); i++)
00547         {
00548           double bv = hc[i]->bValue;
00549           if(maxb<bv)
00550           {
00551             maxb = bv;
00552           }
00553           b_vals.push_back(bv);
00554         }
00555 
00556         for(unsigned int i=0; i<hc.size(); i++)
00557         {
00558           vnl_vector_fixed<double, 3> vect = hc[i]->DiffusionVector;
00559           vect.normalize();
00560           vect *= sqrt(b_vals[i]/maxb);
00561           directions->push_back(vect);
00562         }
00563 
00564         // DWI TO DATATREE
00565         PrintMemoryUsage();
00566         Status(QString("Initializing Diffusion Image"));
00567         typedef mitk::DiffusionImage<PixelValueType> DiffVolumesType;
00568         DiffVolumesType::Pointer diffImage = DiffVolumesType::New();
00569         diffImage->SetDirections(directions);
00570         diffImage->CorrectDKFZBrokenGradientScheme(m_Controls->m_Blur->value());
00571         diffImage->SetVectorImage(vecImage);
00572         diffImage->SetB_Value(maxb);
00573         diffImage->InitializeFromVectorImage();
00574         Status(QString("Diffusion Image initialized"));
00575 
00576         if(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked())
00577         {
00578           PrintMemoryUsage();
00579           Status(QString("Averaging gradient directions"));
00580           diffImage->AverageRedundantGradients(m_Controls->m_Blur->value());
00581         }
00582 
00583         //if(m_Controls->m_DicomLoadDuplicateIfSingleSliceCheckbox->isChecked())
00584         //  diffVolumes->DuplicateIfSingleSlice();
00585 
00586         QString descr = QString("%1_%2_%3")
00587                         .arg(((inHeaders)[0])->seriesDescription.c_str())
00588                         .arg(((inHeaders)[0])->seriesNumber)
00589                         .arg(((inHeaders)[0])->patientName.c_str());
00590         descr = descr.trimmed();
00591         descr = descr.replace(" ", "_");
00592 
00593         if(!m_OutputFolderNameSet)
00594         {
00595           node=mitk::DataNode::New();
00596           node->SetData( diffImage );
00597           GetDefaultDataStorage()->Add(node);
00598           SetDwiNodeProperties(node, descr.toStdString().c_str());
00599           Status(QString("Image %1 added to datastorage").arg(descr));
00600         }
00601         else
00602         {
00603           typedef mitk::NrrdDiffusionImageWriter<PixelValueType> WriterType;
00604           WriterType::Pointer writer = WriterType::New();
00605           QString fullpath = QString("%1/%2.dwi")
00606                              .arg(m_OutputFolderName)
00607                              .arg(descr);
00608           std::string pathstring = itksys::SystemTools::ConvertToOutputPath(fullpath.toStdString().c_str());
00609           writer->SetFileName(pathstring);
00610           writer->SetInput(diffImage);
00611           try
00612           {
00613             writer->Update();
00614           }
00615           catch (itk::ExceptionObject &ex)
00616           {
00617             Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
00618             continue ;
00619           }
00620           Status(QString("Image %1 written to disc (%1)").arg(fullpath.toStdString().c_str()));
00621         }
00622       }
00623       else
00624       {
00625         Status(QString("No diffusion information found (%1)").arg(folderName));
00626       }
00627 
00628       Status(QString("Finished processing %1 with memory:").arg(folderName));
00629       PrintMemoryUsage();
00630       clock.Stop(folderName.toAscii());
00631       mitk::ProgressBar::GetInstance()->Progress();
00632     }
00633 
00634     Status("Timing information");
00635     clock.Report();
00636     
00637     if(!m_OutputFolderNameSet && node.IsNotNull())
00638     {
00639       mitk::BaseData::Pointer basedata = node->GetData();
00640       if (basedata.IsNotNull())
00641       {
00642         mitk::RenderingManager::GetInstance()->InitializeViews(
00643             basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
00644       }
00645     }
00646 
00647     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00648 
00649   }
00650   catch (itk::ExceptionObject &ex)
00651   {
00652     Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
00653     return ;
00654   }
00655 
00656   Status(QString("Finished import with memory:"));
00657   PrintMemoryUsage();
00658 }
00659 
00660 void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
00661 {
00662 
00663   node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
00664 
00665   // set foldername as string property
00666   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
00667   node->SetProperty( "name", nameProp );
00668 }