diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
index bcd274a726..b48b2211c8 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
@@ -1,290 +1,310 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
-#ifndef __mitkNrrdDiffusionImageReader_cpp
-#define __mitkNrrdDiffusionImageReader_cpp
+#ifndef __mitkNrrdTbssImageReader_cpp
+#define __mitkNrrdTbssImageReader_cpp
 
 #include "mitkNrrdTbssImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
 #include <itkImageFileWriter.h>
 
 #include <iostream>
 #include <fstream>
 
 #include "itksys/SystemTools.hxx"
 
+
 namespace mitk
 {  
       void NrrdTbssImageReader
       ::GenerateData()
   {
 
     // Since everything is completely read in GenerateOutputInformation() it is stored
     // in a cache variable. A timestamp is associated.
     // If the timestamp of the cache variable is newer than the MTime, we only need to
     // assign the cache variable to the DataObject.
     // Otherwise, the tree must be read again from the file and OuputInformation must
     // be updated!
     if ( ( ! m_OutputCache ) || ( this->GetMTime( ) > m_CacheTime.GetMTime( ) ) )
     {
       this->GenerateOutputInformation();
       itkWarningMacro("Cache regenerated!");
     }
 
     if (!m_OutputCache)
     {
       itkWarningMacro("Tree cache is empty!")
     }
 
     int vecsize = m_OutputCache->GetImage()->GetVectorLength();
 
     static_cast<OutputType*>(this->GetOutput())
         ->SetImage(m_OutputCache->GetImage());
     static_cast<OutputType*>(this->GetOutput())
         ->SetGroupInfo(m_OutputCache->GetGroupInfo());
     static_cast<OutputType*>(this->GetOutput())
         ->InitializeFromVectorImage();
 
 
   }
 
       void NrrdTbssImageReader
       ::GenerateOutputInformation()
   {
     OutputType::Pointer outputForCache = OutputType::New();
     if ( m_FileName == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
     }
     else
     {
       try
       {
         const std::string& locale = "C";
         const std::string& currLocale = setlocale( LC_ALL, NULL );
 
         if ( locale.compare(currLocale)!=0 )
         {
           try
           {
             MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
             setlocale(LC_ALL, locale.c_str());
           }
           catch(...)
           {
             MITK_INFO << "Could not set locale " << locale;
           }
         }
 
 
-        MITK_INFO << "NrrdDiffusionImageReader READING IMAGE INFORMATION";
+        MITK_INFO << "NrrdTbssImageReader READING IMAGE INFORMATION";
         ImageType::Pointer img;
 
         std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
         ext = itksys::SystemTools::LowerCase(ext);
         if (ext == ".tbss")
         {
           typedef itk::ImageFileReader<ImageType> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetFileName(this->m_FileName);
           itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
           reader->SetImageIO(io);
           reader->Update();
           img = reader->GetOutput();
         }
 
         MITK_INFO << "NrrdTbssImageReader READING HEADER INFORMATION";
 
         if (ext == ".tbss")
         {
 
           itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
           std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
           std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
           std::string metaString;
 
 
-          int numberOfGradientImages = 0;
+          //int numberOfGradientImages = 0;
+          std::string name;
+          int n;
+          std::vector< std::pair<std::string, int> > groups;
 
           for (; itKey != imgMetaKeys.end(); itKey ++)
           {
 
 
             itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
-            if (itKey->find("group") != std::string::npos)
+            if (itKey->find("Group_index") != std::string::npos)
             {
 
+              MITK_INFO << *itKey << " ---> " << metaString;
 
+              std::vector<std::string> tokens;
+              this->Tokenize(metaString, tokens, " ");
 
-            }
+              if(tokens.size()==2)
+              {
 
+                std::cout << tokens.at(0) << " " << tokens.at(1) << std::endl;
+
+                std::pair< std::string, int > p;
+                p.first = tokens.at(0);
+                std::string s = tokens.at(1);
+                p.second = atoi(tokens.at(1).c_str());
+                groups.push_back(p);
+              }
 
-          }
+
+            }
 
 
+          }
 
+          outputForCache->SetGroupInfo(groups);
 
 
         }
 
 
+
         // This call updates the output information of the associated VesselTreeData
         outputForCache->SetImage(img);
 
       //  outputForCache->SetB_Value(m_B_Value);
         //outputForCache->SetDirections(m_DiffusionVectors);
        // outputForCache->SetOriginalDirections(m_OriginalDiffusionVectors);
        // outputForCache->SetMeasurementFrame(m_MeasurementFrame);
 
         // Since we have already read the tree, we can store it in a cache variable
         // so that it can be assigned to the DataObject in GenerateData();
         m_OutputCache = outputForCache;
         m_CacheTime.Modified();
 
         try
         {
           MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
           setlocale(LC_ALL, currLocale.c_str());
         }
         catch(...)
         {
           MITK_INFO << "Could not reset locale " << currLocale;
         }
       }
       catch(std::exception& e)
       {
         MITK_INFO << "Std::Exception while reading file!!";
         MITK_INFO << e.what();
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         MITK_INFO << "Exception while reading file!!";
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
   }
 
 
 
       const char* NrrdTbssImageReader
       ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
        void NrrdTbssImageReader
       ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
       const char* NrrdTbssImageReader
       ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
       void NrrdTbssImageReader
       ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
       const char* NrrdTbssImageReader
       ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
       void NrrdTbssImageReader
       ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
       bool NrrdTbssImageReader
       ::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
   {
 
     // First check the extension
     if(  filename == "" )
       return false;
 
     // check if image is serie
     if( filePattern != "" && filePrefix != "" )
       return false;
 
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".tbss")
     {
       itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
 
       typedef itk::ImageFileReader<ImageType> FileReaderType;
       FileReaderType::Pointer reader = FileReaderType::New();
       reader->SetImageIO(io);
       reader->SetFileName(filename);
 
       try
       {
         reader->Update();
       }
       catch(itk::ExceptionObject e)
       {
         MITK_INFO << e.GetDescription();
         return false;
       }
 
 
 /*
       typename ImageType::Pointer img = reader->GetOutput();
       itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();    
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("tbss") != std::string::npos)
         {
           if (metaString.find("ROI") != std::string::npos)
           {
             return true;
           }
         }
       }
     }
 */
  //  return false;
 
       return true;
     }
     return false;
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
index de4ec8809d..acf474de10 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageReader.h
@@ -1,83 +1,104 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkNrrdTbssImageReader_h
 #define __mitkNrrdTbssImageReader_h
 
 #include "mitkCommon.h"
 #include "mitkFileReader.h"
 #include "mitkTbssImageSource.h"
 #include "itkImage.h"
 #include "itkVectorImage.h"
 #include "mitkTbssImage.h"
 
 namespace mitk
 {
 
   /** \brief 
   */
 
 
   class MitkDiffusionImaging_EXPORT NrrdTbssImageReader : public mitk::TbssImageSource, public FileReader
   {
   public:
 
     typedef mitk::TbssImage OutputType;
     typedef itk::VectorImage<float,3>     ImageType;
     typedef TbssImageSource  TbssVolSourceType;
 
 
 
     mitkClassMacro( NrrdTbssImageReader, TbssVolSourceType )
     itkNewMacro(Self)
 
     const char* GetFileName() const;
     void SetFileName(const char* aFileName);
     const char* GetFilePrefix() const;
     void SetFilePrefix(const char* aFilePrefix);
     const char* GetFilePattern() const;
     void SetFilePattern(const char* aFilePattern);
 
     static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
 
   protected:
 
     /** Does the real work. */
     virtual void GenerateData();
     virtual void GenerateOutputInformation();
 
 
     std::string m_FileName;
     std::string m_FilePrefix;
     std::string m_FilePattern;
 
     std::vector< std::pair<std::string, int> > m_GroupInfo;
 
     OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
 
 
+    void Tokenize(const std::string& str,
+                  std::vector<std::string>& tokens,
+                  const std::string& delimiters = " ")
+    {
+      // Skip delimiters at beginning.
+      std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
+      // Find first "non-delimiter".
+      std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
+
+      while (std::string::npos != pos || std::string::npos != lastPos)
+      {
+          // Found a token, add it to the vector.
+          tokens.push_back(str.substr(lastPos, pos - lastPos));
+          // Skip delimiters.  Note the "not_of"
+          lastPos = str.find_first_not_of(delimiters, pos);
+          // Find next "non-delimiter"
+          pos = str.find_first_of(delimiters, lastPos);
+      }
+    }
+
+
 
   private:
     void operator=(const Self&); //purposely not implemented
   };
 
 } //namespace MITK
 
 //#include "mitkNrrdTbssImageReader.cpp"
 
 #endif // __mitkNrrdTbssImageReader_h
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
index c4d29d1b49..12edb618b2 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
@@ -1,117 +1,148 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-12-10 18:05:13 +0100 (Mi, 10 Dez 2008) $
 Version:   $Revision: 15922 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkNrrdTbssImageWriter__cpp
 #define __mitkNrrdTbssImageWriter__cpp
 
 #include "mitkNrrdTbssImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 //#include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
+#include "boost/lexical_cast.hpp"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdTbssImageWriter::NrrdTbssImageWriter()
   : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
 mitk::NrrdTbssImageWriter::~NrrdTbssImageWriter()
 {}
 
 
 void mitk::NrrdTbssImageWriter::GenerateData()
 {
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == NULL)
   {
     itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is NULL!");
     return;
   }
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
 
 
   itk::VectorImage<float, 3>::Pointer img = input->GetImage();
 
+  std::string key;
+  std::string val;
+
+  std::vector< std::pair <std::string, int> > groups = input->GetGroupInfo();
+
+  std::vector< std::pair <std::string, int> >::iterator it = groups.begin();
+
+  int i=0;
+  while(it != groups.end())
+  {
+    std::pair<std::string, int> p = *it;
+
+    key = "Group_index_" + boost::lexical_cast<std::string>(i);
+    val = " " + p.first + " " + boost::lexical_cast<std::string>(p.second);
+    //sprintf( keybuffer, "Group_index_%04d", std::string(i) );
+    // sprintf( valbuffer, "%1d %1d", p.first, p.second);
+
+    //std::cout << valbuffer << std::endl;
+
+    //itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
+    itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
+    it++;
+    ++i;
+  }
+
+  key = "Measurement info";
+  val = input->GetMeasurementInfo();
+  itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
+
+
   typedef itk::VectorImage<float,3> ImageType;
 
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
 
   typedef itk::ImageFileWriter<ImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->UseInputMetaDataDictionaryOn();
   nrrdWriter->SetInput( img );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(m_FileName);
- // nrrdWriter->UseCompressionOn();
+  nrrdWriter->UseCompressionOn();
   nrrdWriter->SetImageIO(io);
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e << std::endl;
   }
 
   m_Success = true;
 }
 
 
 void mitk::NrrdTbssImageWriter::SetInput( InputType* tbssVol )
 {
   this->ProcessObject::SetNthInput( 0, tbssVol );
 }
 
 
 mitk::TbssImage* mitk::NrrdTbssImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 
 std::vector<std::string> mitk::NrrdTbssImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".tbss");
   return possibleFileExtensions;
 }
 
 #endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
index f9f25ab46b..95d60a6f53 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
@@ -1,54 +1,52 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2007-12-11 14:46:19 +0100 (Di, 11 Dez 2007) $
 Version:   $Revision: 6607 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNrrdTbssRoiImageIOFactory.h"
 #include "mitkIOAdapter.h"
 #include "mitkNrrdTbssRoiImageReader.h"
 
 #include "itkVersion.h"
 
   
 namespace mitk
 {
 
 NrrdTbssRoiImageIOFactory::NrrdTbssRoiImageIOFactory()
-{
-  typedef char PixelType;
-  typedef itk::Image< PixelType, 3 >  ImageType;
-  typedef NrrdTbssRoiImageReader<PixelType> NrrdTbssRoiVolReaderType;
+{  
+  typedef NrrdTbssRoiImageReader NrrdTbssRoiVolReaderType;
   this->RegisterOverride("mitkIOAdapter",
                          "mitkNrrdTbssRoiImageReader",
                          "mitk Tbss Image IO",
                          1,
                          itk::CreateObjectFunction<IOAdapter<NrrdTbssRoiVolReaderType> >::New());
 }
   
 NrrdTbssRoiImageIOFactory::~NrrdTbssRoiImageIOFactory()
 {
 }
 
 const char* NrrdTbssRoiImageIOFactory::GetITKSourceVersion() const
 {
   return ITK_SOURCE_VERSION;
 }
 
 const char* NrrdTbssRoiImageIOFactory::GetDescription() const
 {
   return "NrrdTbssImage IO Factory, allows the loading of NRRD Tbss data";
 }
 
 } // end namespace mitk
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
index 8acbb7fad6..6e4d545051 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
@@ -1,353 +1,353 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkNrrdTbssRoiReader_cpp
 #define __mitkNrrdTbssRoiReader_cpp
 
 #include "mitkNrrdTbssRoiImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
 #include <itkImageFileWriter.h>
 
 #include <iostream>
 #include <fstream>
 
 #include "itksys/SystemTools.hxx"
 
 namespace mitk
 {
 
-  template <class TPixelType>
-      void NrrdTbssRoiImageReader<TPixelType>
+
+  void NrrdTbssRoiImageReader
       ::GenerateData()
   {
 
     try
     {
 
       // Change locale if needed
       const std::string& locale = "C";
       const std::string& currLocale = setlocale( LC_ALL, NULL );
 
       if ( locale.compare(currLocale)!=0 )
       {
         try
         {
           MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
           setlocale(LC_ALL, locale.c_str());
         }
         catch(...)
         {
           MITK_INFO << "Could not set locale " << locale;
         }
       }
 
 
 
       // READ IMAGE INFORMATION
       const unsigned int MINDIM = 3;
       const unsigned int MAXDIM = 4;
 
       MITK_INFO << "loading " << m_FileName << " via mitk::NrrdTbssImageReader... " << std::endl;
 
       // Check to see if we can read the file given the name or prefix
       if ( m_FileName == "" )
       {
         itkWarningMacro( << "Filename is empty!" )
         return ;
       }
 
       itk::NrrdImageIO::Pointer imageIO = itk::NrrdImageIO::New();
       imageIO->SetFileName( m_FileName.c_str() );
       imageIO->ReadImageInformation();
 
       unsigned int ndim = imageIO->GetNumberOfDimensions();
 
       if ( ndim < MINDIM || ndim > MAXDIM )
       {
         itkWarningMacro( << "Sorry, only dimensions 3 is supported. The given file has " << ndim << " dimensions!" )
         return;
       }
 
 
       itk::ImageIORegion ioRegion( ndim );
       itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
       itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
       unsigned int dimensions[ MAXDIM ];
       dimensions[ 0 ] = 0;
       dimensions[ 1 ] = 0;
       dimensions[ 2 ] = 0;
       dimensions[ 3 ] = 0;
 
       float spacing[ MAXDIM ];
       spacing[ 0 ] = 1.0f;
       spacing[ 1 ] = 1.0f;
       spacing[ 2 ] = 1.0f;
       spacing[ 3 ] = 1.0f;
 
 
       Point3D origin;
       origin.Fill(0);
 
       unsigned int i;
       for ( i = 0; i < ndim ; ++i )
       {
         ioStart[ i ] = 0;
         ioSize[ i ] = imageIO->GetDimensions( i );
         if(i<MAXDIM)
         {
           dimensions[ i ] = imageIO->GetDimensions( i );
           spacing[ i ] = imageIO->GetSpacing( i );
           if(spacing[ i ] <= 0)
             spacing[ i ] = 1.0f;
         }
         if(i<3)
         {
           origin[ i ] = imageIO->GetOrigin( i );
         }
       }
 
       ioRegion.SetSize( ioSize );
       ioRegion.SetIndex( ioStart );
 
       MITK_INFO << "ioRegion: " << ioRegion << std::endl;
       imageIO->SetIORegion( ioRegion );
       void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
       imageIO->Read( buffer );
       //mitk::Image::Pointer static_cast<OutputType*>(this->GetOutput())image = mitk::Image::New();
       if((ndim==4) && (dimensions[3]<=1))
         ndim = 3;
       if((ndim==3) && (dimensions[2]<=1))
         ndim = 2;
       mitk::PixelType pixelType( imageIO->GetComponentTypeInfo(), imageIO->GetNumberOfComponents(), imageIO->GetPixelType() );
       static_cast<OutputType*>(this->GetOutput())->Initialize( pixelType, ndim, dimensions );
       static_cast<OutputType*>(this->GetOutput())->SetImportChannel( buffer, 0, Image::ManageMemory );
 
       // access direction of itk::Image and include spacing
       mitk::Matrix3D matrix;
       matrix.SetIdentity();
       unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
       for ( i=0; i < itkDimMax3; ++i)
         for( j=0; j < itkDimMax3; ++j )
           matrix[i][j] = imageIO->GetDirection(j)[i];
 
       // re-initialize PlaneGeometry with origin and direction
       PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>
                                      (static_cast<OutputType*>
                                       (this->GetOutput())->GetSlicedGeometry(0)->GetGeometry2D(0));
       planeGeometry->SetOrigin(origin);
       planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
       // re-initialize SlicedGeometry3D
       SlicedGeometry3D* slicedGeometry = static_cast<OutputType*>(this->GetOutput())->GetSlicedGeometry(0);
       slicedGeometry->InitializeEvenlySpaced(planeGeometry, static_cast<OutputType*>(this->GetOutput())->GetDimension(2));
       slicedGeometry->SetSpacing(spacing);
 
       // re-initialize TimeSlicedGeometry
       static_cast<OutputType*>(this->GetOutput())->GetTimeSlicedGeometry()->InitializeEvenlyTimed(slicedGeometry, static_cast<OutputType*>(this->GetOutput())->GetDimension(3));
 
       buffer = NULL;
       MITK_INFO << "number of image components: "<< static_cast<OutputType*>(this->GetOutput())->GetPixelType().GetNumberOfComponents() << std::endl;
 
 
 
       // READ TBSS HEADER INFORMATION
-      typename ImageType::Pointer img;
+      ImageType::Pointer img;
 
       std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
       ext = itksys::SystemTools::LowerCase(ext);
       if (ext == ".roi")
       {
         typedef itk::ImageFileReader<ImageType> FileReaderType;
-        typename FileReaderType::Pointer reader = FileReaderType::New();
+        FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetFileName(this->m_FileName);
 
         reader->SetImageIO(imageIO);
         reader->Update();
 
         img = reader->GetOutput();
 
         itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
         ReadRoiInfo(imgMetaDictionary);
 
       }
 
 
       // RESET LOCALE
       try
       {
         MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
         setlocale(LC_ALL, currLocale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not reset locale " << currLocale;
       }
 
       MITK_INFO << "...finished!" << std::endl;
 
     }
     catch(std::exception& e)
     {
       MITK_INFO << "Std::Exception while reading file!!";
       MITK_INFO << e.what();
       throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
     }
     catch(...)
     {http://www.wetter.com/deutschland/heidelberg/DE0004329.html
       MITK_INFO << "Exception while reading file!!";
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
     }
 
 
   }
 
 
-  template <class TPixelType>
-      void NrrdTbssRoiImageReader<TPixelType>
+
+  void NrrdTbssRoiImageReader
       ::ReadRoiInfo(itk::MetaDataDictionary dict)
   {
     std::vector<std::string> imgMetaKeys = dict.GetKeys();
     std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
     std::string metaString;
     std::vector< itk::Index<3> > roi;
 
     for (; itKey != imgMetaKeys.end(); itKey ++)
     {
       double x,y,z;
       itk::Index<3> ix;
       itk::ExposeMetaData<std::string> (dict, *itKey, metaString);
 
       if (itKey->find("ROI_index") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
         ix[0] = x; ix[1] = y; ix[2] = z;
         roi.push_back(ix);
       }
       else if(itKey->find("preprocessed FA") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         static_cast<OutputType*>(this->GetOutput())->SetPreprocessedFA(true);
         static_cast<OutputType*>(this->GetOutput())->SetPreprocessedFAFile(metaString);
       }
 
       // Name of structure
       if (itKey->find("structure") != std::string::npos)
       {
         MITK_INFO << *itKey << " ---> " << metaString;
         static_cast<OutputType*>(this->GetOutput())->SetStructure(metaString);
       }
     }
     static_cast<OutputType*>(this->GetOutput())->SetRoi(roi);
 
   }
 
-  template <class TPixelType>
-      const char* NrrdTbssRoiImageReader<TPixelType>
+
+  const char* NrrdTbssRoiImageReader
       ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
-  template <class TPixelType>
-      void NrrdTbssRoiImageReader<TPixelType>
+
+  void NrrdTbssRoiImageReader
       ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
-  template <class TPixelType>
-      const char* NrrdTbssRoiImageReader<TPixelType>
+
+  const char* NrrdTbssRoiImageReader
       ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
-  template <class TPixelType>
-      void NrrdTbssRoiImageReader<TPixelType>
+
+  void NrrdTbssRoiImageReader
       ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
-  template <class TPixelType>
-      const char* NrrdTbssRoiImageReader<TPixelType>
+
+  const char* NrrdTbssRoiImageReader
       ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
-  template <class TPixelType>
-      void NrrdTbssRoiImageReader<TPixelType>
+
+  void NrrdTbssRoiImageReader
       ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
-  template <class TPixelType>
-      bool NrrdTbssRoiImageReader<TPixelType>
+
+  bool NrrdTbssRoiImageReader
       ::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
   {
 
     // First check the extension
     if(  filename == "" )
       return false;
 
     // check if image is serie
     if( filePattern != "" && filePrefix != "" )
       return false;
 
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".roi")
     {
       itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
 
       typedef itk::ImageFileReader<ImageType> FileReaderType;
-      typename FileReaderType::Pointer reader = FileReaderType::New();
+      FileReaderType::Pointer reader = FileReaderType::New();
       reader->SetImageIO(io);
       reader->SetFileName(filename);
 
       try
       {
         reader->Update();
       }
       catch(itk::ExceptionObject e)
       {
         MITK_INFO << e.GetDescription();
         return false;
       }
 
       return true;
 
 
     }
 
     return false;
   }
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.h
index 146d6946b7..79fc14b1cb 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.h
@@ -1,80 +1,80 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkNrrdTbssRoiImageReader_h
 #define __mitkNrrdTbssRoiImageReader_h
 
 #include "mitkCommon.h"
 #include "mitkFileReader.h"
 #include "mitkTbssRoiImageSource.h"
 #include "itkImage.h"
 #include "mitkTbssRoiImage.h"
 
 namespace mitk
 {
 
   /** \brief 
   */
 
-  template < class TPixelType >
-  class MitkDiffusionImaging_EXPORT NrrdTbssRoiImageReader : public mitk::TbssRoiImageSource<TPixelType>, public FileReader
+
+  class MitkDiffusionImaging_EXPORT NrrdTbssRoiImageReader : public mitk::TbssRoiImageSource, public FileReader
   {
   public:
 
-    typedef mitk::TbssRoiImage<TPixelType> OutputType;
-    typedef itk::Image<TPixelType,3>     ImageType;
-    typedef TbssRoiImageSource<TPixelType>  TbssVolSourceType;
+    typedef mitk::TbssRoiImage OutputType;
+    typedef itk::Image<char,3>     ImageType;
+    typedef TbssRoiImageSource  TbssVolSourceType;
 
 
 
     mitkClassMacro( NrrdTbssRoiImageReader, TbssVolSourceType )
     itkNewMacro(Self)
 
     const char* GetFileName() const;
     void SetFileName(const char* aFileName);
     const char* GetFilePrefix() const;
     void SetFilePrefix(const char* aFilePrefix);
     const char* GetFilePattern() const;
     void SetFilePattern(const char* aFilePattern);
 
     static bool CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern);
 
   protected:
 
     /** Does the real work. */
     virtual void GenerateData();
 
     void ReadRoiInfo(itk::MetaDataDictionary dict);
 
     std::string m_FileName;
     std::string m_FilePrefix;
     std::string m_FilePattern;
 
-    typename OutputType::Pointer m_OutputCache;
+    OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
 
 
 
   private:
     void operator=(const Self&); //purposely not implemented
   };
 
 } //namespace MITK
 
-#include "mitkNrrdTbssRoiImageReader.cpp"
+//#include "mitkNrrdTbssRoiImageReader.cpp"
 
 #endif // __mitkNrrdTbssImageReader_h
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
index a585995314..120db54b85 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
@@ -1,146 +1,140 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-12-10 18:05:13 +0100 (Mi, 10 Dez 2008) $
 Version:   $Revision: 15922 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkNrrdTbssRoiImageWriter__cpp
 #define __mitkNrrdTbssRoiImageWriter__cpp
 
 #include "mitkNrrdTbssRoiImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 //#include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 
 #include <iostream>
 #include <fstream>
 
-template<typename TPixelType>
-mitk::NrrdTbssRoiImageWriter<TPixelType>::NrrdTbssRoiImageWriter()
+
+mitk::NrrdTbssRoiImageWriter::NrrdTbssRoiImageWriter()
   : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
-template<typename TPixelType>
-mitk::NrrdTbssRoiImageWriter<TPixelType>::~NrrdTbssRoiImageWriter()
+
+mitk::NrrdTbssRoiImageWriter::~NrrdTbssRoiImageWriter()
 {}
 
-template<typename TPixelType>
-void mitk::NrrdTbssRoiImageWriter<TPixelType>::GenerateData()
+void mitk::NrrdTbssRoiImageWriter::GenerateData()
 {
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == NULL)
   {
     itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is NULL!")
     return;
   }
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" )
     return ;
   }
 
 
 
   itk::Image<char,3>::Pointer img = input->GetImage();
 
 
   char keybuffer[512];
   char valbuffer[512];
 
   std::vector< itk::Index<3> > roi = input->GetRoi();
 
   std::vector< itk::Index<3> >::iterator it = roi.begin();
 
   int i=0;
   while(it != roi.end())
   {
     itk::Index<3> ix = *it;
 
     sprintf( keybuffer, "ROI_index_%04d", i );
     sprintf( valbuffer, "%1d %1d %1d", ix[0],ix[1],ix[2]);
 
     std::cout << valbuffer << std::endl;
 
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
     it++;
     ++i;
   }
 
-  typedef itk::Image<TPixelType,3> ImageType;
+  typedef itk::Image<char,3> ImageType;
 
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
 
   typedef itk::ImageFileWriter<ImageType> WriterType;
-  typename WriterType::Pointer nrrdWriter = WriterType::New();
+  WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->UseInputMetaDataDictionaryOn();
   nrrdWriter->SetInput( img );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(m_FileName);
   // nrrdWriter->UseCompressionOn();
   nrrdWriter->SetImageIO(io);
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e << std::endl;
   }
 
-
-
-
-
-
   m_Success = true;
 }
 
-template<typename TPixelType>
-void mitk::NrrdTbssRoiImageWriter<TPixelType>::SetInput( InputType* tbssVol )
+
+void mitk::NrrdTbssRoiImageWriter::SetInput( InputType* tbssVol )
 {
   this->ProcessObject::SetNthInput( 0, tbssVol );
 }
 
-template<typename TPixelType>
-mitk::TbssRoiImage<TPixelType>* mitk::NrrdTbssRoiImageWriter<TPixelType>::GetInput()
+
+mitk::TbssRoiImage* mitk::NrrdTbssRoiImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
-template<typename TPixelType>
-std::vector<std::string> mitk::NrrdTbssRoiImageWriter<TPixelType>::GetPossibleFileExtensions()
+
+std::vector<std::string> mitk::NrrdTbssRoiImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".roi");
   return possibleFileExtensions;
 }
 
 #endif //__mitkNrrdTbssRoiImageWriter__cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
index 0c36f02150..8da997c75e 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.h
@@ -1,139 +1,139 @@
 /*=========================================================================
  
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-08-27 17:18:46 +0200 (Mi, 27 Aug 2008) $
 Version:   $Revision: 15096 $
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
  
 =========================================================================*/
 
 #ifndef _MITK_NRRDTBSSROIVOL_WRITER__H_
 #define _MITK_NRRDTBSSROIVOL_WRITER__H_
 
 #include <itkProcessObject.h>
 #include <mitkFileWriterWithInformation.h>
 #include <mitkTbssRoiImage.h>
 #include <QString>
 #include "MitkDiffusionImagingExports.h"
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
-template < class TPixelType >
+
 class MitkDiffusionImaging_EXPORT NrrdTbssRoiImageWriter : public mitk::FileWriterWithInformation
 {
 public:
 
     mitkClassMacro( NrrdTbssRoiImageWriter, mitk::FileWriterWithInformation )
 
     mitkWriterMacro
 
     itkNewMacro( Self )
     
-    typedef mitk::TbssRoiImage<TPixelType> InputType;
+    typedef mitk::TbssRoiImage InputType;
     
     /**
      * Sets the filename of the file to write.
      * @param FileName the nameInputType of the file to write.
      */
     itkSetStringMacro( FileName );
 
     /**
      * @returns the name of the file to be written to disk.
      */
     itkGetStringMacro( FileName );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePattern );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePattern );
 
     /**image
      * Sets the input object for the filter.
      * @param input the diffusion volumes to write to file.
      */
     void SetInput( InputType* input );
 
     /**
      * @returns the 0'th input object of the filter.
      */
     InputType* GetInput();
 
     /**
      * Returns false if an error happened during writing
      */
     itkGetMacro( Success, bool );
    
     /**
     * @return possible file extensions for the data type associated with the writer
     */
     virtual std::vector<std::string> GetPossibleFileExtensions();
 
     // FileWriterWithInformation methods
     virtual const char * GetDefaultFilename() { return "TbssRoiImage.roi"; }
     virtual const char * GetFileDialogPattern() { return "Tbss Roi Images (*.roi)"; }
     virtual const char * GetDefaultExtension() { return ".roi"; }
     virtual bool CanWriteBaseDataType(BaseData::Pointer data)
     {
-      return (dynamic_cast<mitk::TbssRoiImage<TPixelType>*>(data.GetPointer()) != NULL);
+      return (dynamic_cast<mitk::TbssRoiImage*>(data.GetPointer()) != NULL);
     }
 
 
     virtual void DoWrite(BaseData::Pointer data) { 
       if (CanWriteBaseDataType(data)) {
-        this->SetInput(dynamic_cast<mitk::TbssRoiImage<TPixelType>*>(data.GetPointer()));
+        this->SetInput(dynamic_cast<mitk::TbssRoiImage*>(data.GetPointer()));
         this->Update(); 
       }
     }
 
 protected:
         
     NrrdTbssRoiImageWriter();
 
     virtual ~NrrdTbssRoiImageWriter();
 
     virtual void GenerateData();
     
     std::string m_FileName;
 
     std::string m_FilePrefix;
 
     std::string m_FilePattern;
     
     bool m_Success;
             
 };    
        
 
 } // end of namespace mitk
 
-#include "mitkNrrdTbssRoiImageWriter.cpp"
+//#include "mitkNrrdTbssRoiImageWriter.cpp"
 
 #endif
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
index 7cd4de127d..abf3795205 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
@@ -1,52 +1,51 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2007-12-11 14:46:19 +0100 (Di, 11 Dez 2007) $
 Version:   $Revision: 11215 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNrrdTbssRoiImageWriterFactory.h"
 
 #include "itkCreateObjectFunction.h"
 #include "itkVersion.h"
 
 #include <mitkNrrdTbssRoiImageWriter.h>
 
 namespace mitk
 {
 
 NrrdTbssRoiImageWriterFactory::NrrdTbssRoiImageWriterFactory()
 {
-  typedef char TbssRoiPixelType;
   this->RegisterOverride("IOWriter",
                          "NrrdTbssRoiImageWriter",
                          "NrrdTbssRoiImage ROI Writer",
                          1,
-                         itk::CreateObjectFunction< mitk::NrrdTbssRoiImageWriter<TbssRoiPixelType> >::New());
+                         itk::CreateObjectFunction< mitk::NrrdTbssRoiImageWriter >::New());
 }
 
 NrrdTbssRoiImageWriterFactory::~NrrdTbssRoiImageWriterFactory()
 {
 }
 
 const char* NrrdTbssRoiImageWriterFactory::GetITKSourceVersion() const
 {
   return ITK_SOURCE_VERSION;
 }
 
 const char* NrrdTbssRoiImageWriterFactory::GetDescription() const
 {
   return "NrrdTbssRoiImageWriterFactory";
 }
 
 } // end namespace mitk
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
index 0476cba725..c8cad4a39e 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImage.h
@@ -1,125 +1,137 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-07 17:17:57 +0100 (Do, 07 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef __mitkTbssImage__h
 #define __mitkTbssImage__h
 
 #include "mitkImage.h"
 #include "itkVectorImage.h"
 #include "mitkImageCast.h"
 #include "MitkDiffusionImagingExports.h"
 
 namespace mitk 
 {
 
   /**
   * \brief this class encapsulates diffusion volumes (vectorimages not
   * yet supported by mitkImage)
   */
 
   class MitkDiffusionImaging_EXPORT TbssImage : public Image
   {
 
   public:
 
     typedef itk::VectorImage<float, 3> ImageType;
 
 
     typedef itk::Index<3> IndexType;
     //typedef typename std::vector <Index<3> > RoiType;
 
     mitkClassMacro( TbssImage, Image )
     itkNewMacro(Self)
 
 
     //void SetRequestedRegionToLargestPossibleReg tbssRoi->SetTbssType(mitk::TbssImage<char>::ROI);ion();
     //bool RequestedRegionIsOutsideOfTheBufferedRegion();
     //virtual bool VerifyRequestedRegion();
     //void SetRequestedRegion(itk::DataObject *data);
 
     ImageType::Pointer GetImage()
     {
       return m_Image;
     }
     void SetImage(ImageType::Pointer image )
     {
       this->m_Image = image;
     }
 
 
     void InitializeFromImage()
     {
       MITK_INFO << "make an mitk image that can be shown by mitk";
       this->InitializeByItk(m_Image.GetPointer(),1,1);
     }
 
     void SetGroupInfo( std::vector< std::pair<std::string, int> > info)
     {
       m_GroupInfo = info;
     }
 
     std::vector< std::pair<std::string, int> > GetGroupInfo()
     {
       return m_GroupInfo;
     }
 
+    void SetMeasurementInfo(std::string s)
+    {
+      m_MeasurementInfo = s;
+    }
+
+    std::string GetMeasurementInfo()
+    {
+      return m_MeasurementInfo;
+    }
+
     void InitializeFromVectorImage();
 
     void SetDisplayIndexForRendering(int displayIndex);
 
 
 
   protected:
 
     TbssImage();
 
     virtual ~TbssImage(){}
 
     ImageType::Pointer m_Image;
 
 
     std::vector< std::pair<std::string, int> > m_GroupInfo;
 
     int m_DisplayIndex;
 
+    std::string m_MeasurementInfo;
+
 
 
 
   };
 
 /*
   // Does the same es the normal CastToMitkImage, but needed to reimplemented due to the templatet pixeltype
   template <typename ItkOutputImageType>
   void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssImage >& tbssoutputimage)
   {
     if(tbssoutputimage.IsNull())
     {
       tbssoutputimage = mitk::TbssImage::New();
     }
     tbssoutputimage->InitializeByItk(itkimage);
     tbssoutputimage->SetChannel(itkimage->GetBufferPointer());
   }
 
 
 */
 
 
 
 } // namespace mitk
 //#include "mitkTbssImage.cpp"
 #endif /* __mitkTbssImage__h */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
index 18310773e4..0b72c2ff5f 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.cpp
@@ -1,201 +1,203 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkTbssImporter_cpp
 #define __mitkTbssImporter_cpp
 
 #include "mitkTbssImporter.h"
 #include <QDir>
 #include <QStringList>
 
 
 
 namespace mitk
 {
 
   mitk::TbssImporter::TbssImporter()
   {
 
   }
 
 
   mitk::TbssImporter::TbssImporter(std::string path) : m_InputPath(path)
   {
 
   }
 
 
 
   mitk::TbssImage::Pointer mitk::TbssImporter::Import()
   {
     // read all images with all_*.nii.gz
     mitk::TbssImage::Pointer tbssImg = mitk::TbssImage::New();
 
 
     QDir currentDir = QDir(QString(m_InputPath.c_str()));
     currentDir.setFilter( QDir::Files );
     QStringList entries = currentDir.entryList();
 
 
 
     for(int e=0; e<entries.size(); e++)
     {
 
       std::string filename = entries.at(e).toStdString();
 
-      if (std::string::npos != filename.find("vectorimage"))
+      if (std::string::npos != filename.find("all_FA_skeletonised.nii.gz"))
       {
 
         // Found a 4d skeletonized image
         if(m_InputPath.find_last_of("/") != m_InputPath.size()-1)
         {
           m_InputPath += "/";
         }
 
         std::string file = m_InputPath + filename;
         FileReaderType4D::Pointer reader = FileReaderType4D::New();
         reader->SetFileName(file);
         reader->Update();
 
         FloatImage4DType::Pointer img = FloatImage4DType::New();
         img = reader->GetOutput();
 
         //Create new m_Data (only once)
         if(m_Data.IsNull())
         {
           m_Data = DataImageType::New();
 
 
           FloatImage4DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
           FloatImage4DType::SpacingType spacing = img->GetSpacing();
 
 
           DataImageType::SizeType dataSize;
           dataSize[0] = size[0];
           dataSize[1] = size[1];
           dataSize[2] = size[2];
 
           m_Data->SetRegions(dataSize);
 
 
           DataImageType::SpacingType dataSpacing;
           dataSpacing[0] = spacing[0];
           dataSpacing[1] = spacing[1];
           dataSpacing[2] = spacing[2];
 
           m_Data->SetSpacing(dataSpacing);
 
           FloatImage4DType::PointType origin = img->GetOrigin();
 
           DataImageType::PointType dataOrigin;
           dataOrigin[0] = origin[0];
           dataOrigin[1] = origin[1];
           dataOrigin[2] = origin[2];
 
           m_Data->SetOrigin(dataOrigin);
 
 
           FloatImage4DType::DirectionType dir = img->GetDirection();
 
           DataImageType::DirectionType dataDir;
           for(int i=0; i<=2; i++)
           {
             for(int j=0; j<=2; j++)
             {
               dataDir[i][j] = dir[i][j];
             }
           }
 
           m_Data->SetDirection(dataDir);
 
           //VariableLengthVector<float> vec;
           //vec.SetElement(i, 0.0);
           //m_Data->FillBuffer(0.0);
 
 
           // Set the length to one because otherwise allocate fails. Should be changed when groups/measurements are added
-          m_Data->SetVectorLength(3);
+          m_Data->SetVectorLength(size[3]);
           m_Data->Allocate();
 
 
 
         }
 
 
         // m_Data should be allocated here so move on filling it with values from the 4D image
         FloatImage4DType::SizeType size = img->GetLargestPossibleRegion().GetSize();
 
         for(int i=0; i<size[0]; i++)
         {
           for(int j=0; j<size[1]; j++)
           {
             for(int k=0; k<size[2]; k++)
             {
               itk::Index<3> ix;
               ix[0] = i;
               ix[1] = j;
               ix[2] = k;
               itk::VariableLengthVector<float> pixel = m_Data->GetPixel(ix);
               int vecSize = pixel.Size();
 
               for(int z=0; z<size[3]; z++)
               {
                 itk::Index<4> ix4;
                 ix4[0] = i;
                 ix4[1] = j;
                 ix4[2] = k;
                 ix4[3] = z;
                 float value = img->GetPixel(ix4);
 
 
                 pixel.SetElement(z, value);
               }
               m_Data->SetPixel(ix, pixel);
             }
           }
         }
 
 
         std::cout << "found!" << std::endl;
       }
 
 
 
     }
 
 
 //    mitk::CastToTbssImage(m_Data.GetPointer(), tbssImg);
 
 
 
+
     tbssImg->SetGroupInfo(m_Groups);
+    tbssImg->SetMeasurementInfo(m_MeasurementInfo);
     tbssImg->SetImage(m_Data);
 
     int vecsize = m_Data->GetVectorLength();
 
     tbssImg->InitializeFromVectorImage();
 
     return tbssImg;
 
   }
 
 
 }
 
 
 
 #endif // __mitkTbssImporter_cpp
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
index 5247901e1a..f4c88cbea3 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssImporter.h
@@ -1,86 +1,98 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkTbssImporter_h
 #define __mitkTbssImporter_h
 
 #include "mitkCommon.h"
 #include "mitkFileReader.h"
 
 #include "itkImage.h"
 #include "itkVectorImage.h"
 #include "itkImageFileReader.h"
 #include "mitkTbssImage.h"
 
 
 namespace mitk
 {
   //template<class TPixelType>
   class TbssImporter : public itk::Object {
 
   public:
    // typedef TPixelType PixelType;
     typedef itk::VectorImage<float,3> DataImageType; // type of the 3d vector image containing the skeletonized images
     typedef itk::Image<float, 4> FloatImage4DType;
     typedef itk::ImageFileReader<FloatImage4DType> FileReaderType4D;
 
     TbssImporter();
 
     mitkClassMacro( TbssImporter, Object )
     itkNewMacro(Self)
 
 
 
     TbssImporter(std::string path);
 
     void SetInputPath(std::string p)
     {
       m_InputPath = p;
     }
 
     mitk::TbssImage::Pointer Import();
 
 
     void SetGroupInfo(std::vector< std::pair<std::string, int> > groups)
     {
       m_Groups = groups;
     }
 
     std::vector< std::pair<std::string, int> > GetGroupInfo()
     {
       return m_Groups;
     }
 
+    void SetMeasurementInfo(std::string s)
+    {
+      m_MeasurementInfo = s;
+    }
+
+    std::string GetMeasurementInfo()
+    {
+      return m_MeasurementInfo;
+    }
+
 
   protected:
 
 
 
     virtual ~TbssImporter(){}
 
     std::string m_InputPath;
 
     DataImageType::Pointer m_Data;
     std::vector< std::pair<std::string, int> > m_Groups;
 
+    std::string m_MeasurementInfo;
+
 
   };
 
 }
 
 #include "mitkTbssImporter.cpp"
 #endif // __mitkTbssImporter_h
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.cpp
index f847079050..1ca853f599 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.cpp
@@ -1,57 +1,57 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-08 11:19:03 +0100 (Fr, 08 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __mitkTbssRoiImage__cpp
 #define __mitkTbssRoiImage__cpp
 
 
 #include "mitkTbssRoiImage.h"
 #include "itkImageRegionIterator.h"
 #include "itkImageRegionConstIterator.h"
 #include "mitkImageCast.h"
 
 
 
-template<typename TPixelType>
-mitk::TbssRoiImage<TPixelType>::TbssRoiImage() : m_PreprocessedFA(false)
+
+mitk::TbssRoiImage::TbssRoiImage() : m_PreprocessedFA(false)
 {
 
 }
 
 /*
 template<typename TPixelType>
 mitk::TbssImage<TPixelType>::TbssImage()
 {
 
 }
 
 template<typename TPixelType>
 mitk::TbssImage<TPixelType>::~TbssImage()
 {
 
 }
 
 
 template<typename TPixelType>
 void mitk::TbssImage<TPixelType>::InitializeFromImage()
 {
 
 }
 
 
 */
 #endif /* __mitkTbssImage__cpp */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.h
index bbbdf3dbf8..926ab907d4 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImage.h
@@ -1,126 +1,126 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-02-07 17:17:57 +0100 (Do, 07 Feb 2008) $
 Version:   $Revision: 11989 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef __mitkTbssRoiImage__h
 #define __mitkTbssRoiImage__h
 
 #include "mitkImage.h"
 #include "itkImage.h"
 #include "mitkImageCast.h"
 
 namespace mitk 
 {
 
   /**
   * \brief this class encapsulates diffusion volumes (vectorimages not
   * yet supported by mitkImage)
   */
-  template<class TPixelType>
+
   class TbssRoiImage : public Image
   {
 
   public:
-    typedef TPixelType PixelType;
-    typedef typename itk::Image<TPixelType, 3>  ImageType;
+
+    typedef itk::Image<char, 3>  ImageType;
     typedef itk::Index<3> IndexType;
     //typedef typename std::vector <Index<3> > RoiType;
 
     mitkClassMacro( TbssRoiImage, Image )
     itkNewMacro(Self)
 
 
     //void SetRequestedRegionToLargestPossibleRegion();
     //bool RequestedRegionIsOutsideOfTheBufferedRegion();
     //virtual bool VerifyRequestedRegion();
     //void SetRequestedRegion(itk::DataObject *data);
 
-    typename ImageType::Pointer GetImage()
+    ImageType::Pointer GetImage()
     {
       return m_Image;
     }
-    void SetImage(typename ImageType::Pointer image )
+    void SetImage(ImageType::Pointer image )
     {
       this->m_Image = image;
     }
 
     itkGetMacro(PreprocessedFA, bool)
     itkSetMacro(PreprocessedFA, bool)
     itkGetMacro(PreprocessedFAFile, std::string)
     itkSetMacro(PreprocessedFAFile, std::string)
     itkGetMacro(Structure, std::string)
     itkSetMacro(Structure, std::string)
 
     void SetRoi(std::vector< itk::Index<3> > roi)
     {
       m_Roi = roi;
     }
 
 
     // depricated
     std::vector< itk::Index<3> > GetRoi()
     {
       return m_Roi;
     }
 
     void InitializeFromImage()
     {
       MITK_INFO << "make an mitk image that can be shown by mitk";
       this->InitializeByItk(m_Image.GetPointer(),1,1);
     }
 
 
     TbssRoiImage();
 
   protected:
 
     virtual ~TbssRoiImage(){}
 
-    typename ImageType::Pointer m_Image;
+    ImageType::Pointer m_Image;
 
     std::vector< itk::Index<3> > m_Roi;
 
     bool m_PreprocessedFA;
     std::string m_PreprocessedFAFile;
 
     std::string m_Structure;
 
 
   };
 
 
   // Does the same es the normal CastToMitkImage, but needed to reimplemented due to the templatet pixeltype
-  template <typename ItkOutputImageType, typename PixelType>
-  void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssRoiImage<PixelType> >& tbssoutputimage)
+  template <typename ItkOutputImageType>
+  void CastToTbssImage(const ItkOutputImageType* itkimage, itk::SmartPointer< mitk::TbssRoiImage >& tbssoutputimage)
   {
     if(tbssoutputimage.IsNull())
     {
-      tbssoutputimage = mitk::TbssRoiImage<PixelType>::New();
+      tbssoutputimage = mitk::TbssRoiImage::New();
     }
     tbssoutputimage->InitializeByItk(itkimage);
     tbssoutputimage->SetChannel(itkimage->GetBufferPointer());
   }
 
 
 
 
 
 
 } // namespace mitk
 
-#include "mitkTbssRoiImage.cpp"
+//#include "mitkTbssRoiImage.cpp"
 #endif /* __mitkTbssRoiImage__h */
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
index 0f6a3331aa..6a52b7c752 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
@@ -1,53 +1,52 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2007-12-11 14:46:19 +0100 (Di, 11 Dez 2007) $
 Version:   $Revision: 10345 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef __MITK_NRRD_TBSSROI_VOLUMES_IO_FACTORY_CPP__
 #define __MITK_NRRD_TBSSROI_VOLUMES_IO_FACTORY_CPP__
 
 #include "mitkTbssRoiImageSource.h"
 #include "mitkTbssRoiImage.h"
 
-template<typename TPixelType>
-mitk::TbssRoiImageSource<TPixelType>::TbssRoiImageSource()
+
+mitk::TbssRoiImageSource::TbssRoiImageSource()
 {
   // Create the output. We use static_cast<> here because we know the default
   // output must be of type DiffusionImage
-  typename mitk::TbssRoiImage<TPixelType>::Pointer output
-    = static_cast<typename mitk::TbssRoiImage<TPixelType>*>(this->MakeOutput(0).GetPointer());
+  mitk::TbssRoiImage::Pointer output
+    = static_cast<mitk::TbssRoiImage*>(this->MakeOutput(0).GetPointer());
 
   Superclass::SetNumberOfRequiredOutputs(1);
   Superclass::SetNthOutput(0, output.GetPointer());
 }
 
 
-template<typename TPixelType>
-itk::DataObject::Pointer mitk::TbssRoiImageSource<TPixelType>::MakeOutput( unsigned int /*idx*/ )
+itk::DataObject::Pointer mitk::TbssRoiImageSource::MakeOutput( unsigned int /*idx*/ )
 {
-  return static_cast<itk::DataObject*>(mitk::TbssRoiImage<TPixelType>::New().GetPointer());
+  return static_cast<itk::DataObject*>(mitk::TbssRoiImage::New().GetPointer());
 }
 
 /*
 template<typename TPixelType>
 mitk::TbssImageSource<TPixelType>::OutputType* mitk::TbssImageSource::GetOutput(unsigned int idx)
 {
   return static_cast<OutputType*>
                      (this->ProcessObject::GetOutput(idx));
 }
 
 */
 
 #endif //__MITK_NRRD_TBSS_VOULMES_IO_FACTORY_CPP__
diff --git a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.h b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
index f3af8e72a2..466d3db518 100644
--- a/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
+++ b/Modules/DiffusionImaging/IODataStructures/TbssImages/mitkTbssRoiImageSource.h
@@ -1,76 +1,76 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-13 18:06:46 +0200 (Mi, 13 Mai 2009) $
 Version:   $Revision: 5308 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef _MITK_TBSS_ROI_IMAGE_DATA_SOURCE_H_HEADER_
 #define _MITK_TBSS_ROI_IMAGE_DATA_SOURCE_H_HEADER_
 
 
 // Should be changed in a new type for TBSS
 #include "mitkImageSource.h"
 #include "MitkDiffusionImagingExports.h"
 
 
 namespace mitk {
 
-  template<typename TPixelType>
+
 
   class TbssRoiImage;
 
 
 //##Documentation
 //## @brief Superclass of all classes generating diffusion volumes (instances 
 //## of class DiffusionImage) as output. 
 //##
 //## @ingroup Process
-template<typename TPixelType>
+
 class MitkDiffusionImaging_EXPORT TbssRoiImageSource : public ImageSource
 {
 public:
   mitkClassMacro(TbssRoiImageSource, BaseProcess)
   itkNewMacro(Self)
 
-  typedef TbssRoiImage<TPixelType> OutputType;
+  typedef TbssRoiImage OutputType;
   typedef itk::DataObject::Pointer DataObjectPointer;
 
   virtual DataObjectPointer MakeOutput(unsigned int idx);
 
   //OutputType * GetOutput(unsigned int idx);
 
   //void SetOutput(OutputType* output);
 
   //OutputType* GetOutput()
   //{return Superclass::GetOutput();}
 
   //OutputType* GetOutput(unsigned int idx);
 
   //virtual void GraftOutput(OutputType* graft);
 
   //virtual void GraftNthOutput(unsigned int idx, OutputType *graft);
 
 protected:
   TbssRoiImageSource();
 
   virtual ~TbssRoiImageSource(){}
 };
 
 } // namespace mitk
 
-#include "mitkTbssRoiImageSource.cpp"
+//#include "mitkTbssRoiImageSource.cpp"
 
 
 #endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
index cde7bfa57a..ed31a608d0 100644
--- a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
@@ -1,352 +1,352 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-06-18 15:59:04 +0200 (Do, 18 Jun 2009) $
 Version:   $Revision: 16916 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkDiffusionImagingObjectFactory.h"
 
 #include "mitkProperties.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 
 #include "mitkNrrdDiffusionImageIOFactory.h"
 #include "mitkNrrdDiffusionImageWriterFactory.h"
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "mitkDiffusionImage.h"
 
 #include "mitkNrrdQBallImageIOFactory.h"
 #include "mitkNrrdQBallImageWriterFactory.h"
 #include "mitkNrrdQBallImageWriter.h"
 
 #include "mitkNrrdTensorImageIOFactory.h"
 #include "mitkNrrdTensorImageWriterFactory.h"
 #include "mitkNrrdTensorImageWriter.h"
 
 #include "mitkCompositeMapper.h"
 #include "mitkDiffusionImageMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 #include "mitkTbssImageMapper.h"
 
 //====depricated fiberstructure=====
 #include "mitkFiberBundle.h"
 #include "mitkFiberBundleMapper3D.h"
 #include "mitkFiberBundleIOFactory.h"
 #include "mitkFiberBundleWriterFactory.h"
 #include "mitkFiberBundleWriter.h"
 //==================================
 
 //modernized fiberbundle datastrucutre
 #include "mitkFiberBundleX.h"
 #include "mitkFiberBundleXIOFactory.h"
 #include "mitkFiberBundleXWriterFactory.h"
 #include "mitkFiberBundleXWriter.h"
 #include "mitkFiberBundleXMapper3D.h"
 
 #include "mitkFiberBundleXThreadMonitorMapper3D.h"
 #include "mitkFiberBundleXThreadMonitor.h"
 
 #include "mitkNrrdTbssImageIOFactory.h"
 #include "mitkNrrdTbssImageWriterFactory.h"
 #include "mitkNrrdTbssImageWriter.h"
 
 #include "mitkNrrdTbssRoiImageIOFactory.h"
 #include "mitkNrrdTbssRoiImageWriterFactory.h"
 #include "mitkNrrdTbssRoiImageWriter.h"
 
 
 typedef short DiffusionPixelType;
 typedef char TbssRoiPixelType;
 typedef float TbssPixelType;
 
 
 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionImagingObjectFactory::DiffusionImagingObjectFactory(bool /*registerSelf*/)
 :CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_INFO << "DiffusionImagingObjectFactory c'tor" << std::endl;
     RegisterIOFactories();
 
 
     mitk::NrrdDiffusionImageIOFactory::RegisterOneFactory();
     mitk::NrrdQBallImageIOFactory::RegisterOneFactory();
     mitk::NrrdTensorImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleIOFactory::RegisterOneFactory();
     mitk::NrrdTbssImageIOFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageIOFactory::RegisterOneFactory();
     mitk::FiberBundleXIOFactory::RegisterOneFactory(); //modernized
 
 
     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssImageWriterFactory::RegisterOneFactory();
     mitk::NrrdTbssRoiImageWriterFactory::RegisterOneFactory();
     mitk::FiberBundleXWriterFactory::RegisterOneFactory();//modernized
 
     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleWriter::New().GetPointer() );
     m_FileWriters.push_back( NrrdTbssImageWriter::New().GetPointer() );
-    m_FileWriters.push_back( NrrdTbssRoiImageWriter<TbssRoiPixelType>::New().GetPointer() );
+    m_FileWriters.push_back( NrrdTbssRoiImageWriter::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
 
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::Mapper::Pointer mitk::DiffusionImagingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
 
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::DiffusionImageMapper<short>::New();
       newMapper->SetDataNode(node);
     }
     mitk::Mapper::Pointer newMapper=NULL;
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "DiffusionImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleXThreadMonitor";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleXThreadMonitorMapper3D::New();
       newMapper->SetDataNode(node); 
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::VolumeDataVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {  
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
   }
 
   return newMapper;
 }
 
 void mitk::DiffusionImagingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname = "QBallImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TensorImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "DiffusionImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleMapper3D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleX";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleXThreadMonitor";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(node);
   }
   
   classname = "TbssRoiImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TbssImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::DiffusionImagingObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::DiffusionImagingObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fsl", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fslgz", "Diffusion Weighted Images for FSL"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.fib", "Fiber Bundle"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vfib", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Fiber Bundle Polydata"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tbss", "TBSS data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
 }
 
 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionImagingObjectFactory()
 {
   static bool oneDiffusionImagingObjectFactoryRegistered = false;
   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
     MITK_INFO << "Registering DiffusionImagingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
 
     oneDiffusionImagingObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/DiffusionImaging/files.cmake b/Modules/DiffusionImaging/files.cmake
index 374e9f1055..cb5c562f58 100644
--- a/Modules/DiffusionImaging/files.cmake
+++ b/Modules/DiffusionImaging/files.cmake
@@ -1,164 +1,164 @@
 SET(CPP_FILES
 
   # DicomImport
   DicomImport/mitkDicomDiffusionImageReader.cpp
   DicomImport/mitkGroupDiffusionHeadersFilter.cpp
   DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
 
   # DataStructures
   IODataStructures/mitkDiffusionImagingObjectFactory.cpp
 
   # DataStructures -> DWI
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageReader.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriter.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageIOFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriterFactory.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSerializer.cpp
 
   # DataStructures -> QBall
   IODataStructures/QBallImages/mitkQBallImageSource.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriter.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageIOFactory.cpp
   IODataStructures/QBallImages/mitkNrrdQBallImageWriterFactory.cpp
   IODataStructures/QBallImages/mitkQBallImage.cpp
   IODataStructures/QBallImages/mitkQBallImageSerializer.cpp
 
   # DataStructures -> Tensor
   IODataStructures/TensorImages/mitkTensorImageSource.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriter.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageIOFactory.cpp
   IODataStructures/TensorImages/mitkNrrdTensorImageWriterFactory.cpp
   IODataStructures/TensorImages/mitkTensorImage.cpp
   IODataStructures/TensorImages/mitkTensorImageSerializer.cpp
 
   # DataStructures -> FiberBundle
   IODataStructures/FiberBundle/mitkFiberBundle.cpp
   IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp
   IODataStructures/FiberBundle/mitkFiberBundleReader.cpp
   IODataStructures/FiberBundle/mitkFiberBundleIOFactory.cpp
   IODataStructures/FiberBundle/mitkFiberBundleWriterFactory.cpp
   IODataStructures/FiberBundle/mitkFiberBundleSerializer.cpp
   IODataStructures/FiberBundle/mitkParticle.cpp
   IODataStructures/FiberBundle/mitkParticleGrid.cpp
 
 # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.cpp
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp
 
 
   # DataStructures -> PlanarFigureComposite
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
 
 
   # DataStructures -> Tbss
   IODataStructures/TbssImages/mitkTbssImageSource.cpp
   IODataStructures/TbssImages/mitkTbssRoiImageSource.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageIOFactory.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageReader.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageIOFactory.cpp
   IODataStructures/TbssImages/mitkTbssImage.cpp
   IODataStructures/TbssImages/mitkTbssRoiImage.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriterFactory.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriter.cpp
   IODataStructures/TbssImages/mitkNrrdTbssRoiImageWriterFactory.cpp
   IODataStructures/TbssImages/mitkTbssImporter.cpp
 
 
   # Rendering
   Rendering/vtkMaskedProgrammableGlyphFilter.cpp
   Rendering/mitkCompositeMapper.cpp
   Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
   Rendering/vtkOdfSource.cxx
   Rendering/vtkThickPlane.cxx
   Rendering/mitkOdfNormalizationMethodProperty.cpp
   Rendering/mitkOdfScaleByProperty.cpp
   Rendering/mitkFiberBundleMapper3D.cpp
   Rendering/mitkFiberBundleXMapper3D.cpp
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp
   Rendering/mitkTbssImageMapper.cpp
   
 # Interactions
   Interactions/mitkFiberBundleInteractor.cpp
 
   # Algorithms
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
 )
 
 SET(H_FILES
   # Rendering
   Rendering/mitkDiffusionImageMapper.h
   Rendering/mitkTbssImageMapper.h
   Rendering/mitkOdfVtkMapper2D.h
   Rendering/mitkFiberBundleMapper3D.h
   Rendering/mitkFiberBundleXMapper3D.h
   Rendering/mitkFiberBundleXThreadMonitorMapper3D.h
 
   # Reconstruction
   Reconstruction/itkDiffusionQballReconstructionImageFilter.h
   Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
   Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
   Reconstruction/itkPointShell.h
   Reconstruction/itkOrientationDistributionFunction.h
 
   # IO Datastructures
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
   IODataStructures/FiberBundle/itkSlowPolyLineParametricPath.h
   #IODataStructures/TbssImages/mitkTbssImage.h
-  IODataStructures/TbssImages/mitkTbssRoiImage.h
+  #IODataStructures/TbssImages/mitkTbssRoiImage.h
 
   # DataStructures -> FiberBundleX
   IODataStructures/FiberBundleX/mitkFiberBundleX.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriter.h
   IODataStructures/FiberBundleX/mitkFiberBundleXReader.h
   IODataStructures/FiberBundleX/mitkFiberBundleXIOFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXWriterFactory.h
   IODataStructures/FiberBundleX/mitkFiberBundleXSerializer.h
   IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h
 
 
 
   # Tractography
   Tractography/itkGibbsTrackingFilter.h
 
   # Algorithms
   Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
   Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
   Algorithms/itkTensorDerivedMeasurementsFilter.h
   Algorithms/itkBrainMaskExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionImageFilter.h
   Algorithms/itkTensorImageToDiffusionImageFilter.h
   Algorithms/itkTensorToL2NormImageFilter.h
   Algorithms/itkTractsToProbabilityImageFilter.h
   Algorithms/itkTractsToDWIImageFilter.h
   Algorithms/itkTractsToFiberEndingsImageFilter.h
   Algorithms/itkGaussianInterpolateImageFunction.h
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
   Algorithms/itkDiffusionTensorPrincipleDirectionImageFilter.h
   Algorithms/itkCartesianToPolarVectorImageFilter.h
   Algorithms/itkPolarToCartesianVectorImageFilter.h
 )
 
 SET( TOOL_FILES
 )
 
 IF(WIN32)
 ENDIF(WIN32)
 
 #MITK_MULTIPLEX_PICTYPE( Algorithms/mitkImageRegistrationMethod-TYPE.cpp )