diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp
index d0316eab70..1a9019a926 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.cpp
@@ -1,231 +1,231 @@
 /*=========================================================================
 
 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.
 
 =========================================================================*/
 
 #include "mitkFiberBundleWriter.h"
 #include <tinyxml.h>
 
 const char* mitk::FiberBundleWriter::XML_GEOMETRY = "geometry";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_XX = "xx";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_XY = "xy";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_XZ = "xz";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_YX = "yx";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_YY = "yy";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_YZ = "yz";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_ZX = "zx";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_ZY = "zy";
 
 const char* mitk::FiberBundleWriter::XML_MATRIX_ZZ = "zz";
 
 const char* mitk::FiberBundleWriter::XML_ORIGIN_X = "origin_x";
 
 const char* mitk::FiberBundleWriter::XML_ORIGIN_Y = "origin_y";
 
 const char* mitk::FiberBundleWriter::XML_ORIGIN_Z = "origin_z";
 
 const char* mitk::FiberBundleWriter::XML_SPACING_X = "spacing_x";
 
 const char* mitk::FiberBundleWriter::XML_SPACING_Y = "spacing_y";
 
 const char* mitk::FiberBundleWriter::XML_SPACING_Z = "spacing_z";
 
 const char* mitk::FiberBundleWriter::XML_SIZE_X = "size_x";
 
 const char* mitk::FiberBundleWriter::XML_SIZE_Y = "size_y";
 
 const char* mitk::FiberBundleWriter::XML_SIZE_Z = "size_z";
 
 const char* mitk::FiberBundleWriter::XML_FIBER_BUNDLE = "fiber_bundle";
 
 const char* mitk::FiberBundleWriter::XML_FIBER = "fiber";
 
 const char* mitk::FiberBundleWriter::XML_PARTICLE = "particle";
 
 const char* mitk::FiberBundleWriter::XML_ID = "id";
 
 const char* mitk::FiberBundleWriter::XML_POS_X = "pos_x";
 
 const char* mitk::FiberBundleWriter::XML_POS_Y = "pos_y";
 
 const char* mitk::FiberBundleWriter::XML_POS_Z = "pos_z";
 
 const char* mitk::FiberBundleWriter::XML_NUM_FIBERS = "num_fibers";
 
 const char* mitk::FiberBundleWriter::XML_NUM_PARTICLES = "num_particles";
 
 const char* mitk::FiberBundleWriter::XML_FIBER_BUNDLE_FILE = "fiber_bundle_file" ;
 
 const char* mitk::FiberBundleWriter::XML_FILE_VERSION = "file_version" ;
 
 const char* mitk::FiberBundleWriter::VERSION_STRING = "0.1" ;
 
 const char* mitk::FiberBundleWriter::ASCII_FILE = "ascii_file" ;
 
 const char* mitk::FiberBundleWriter::FILE_NAME = "file_name" ;
 
 mitk::FiberBundleWriter::FiberBundleWriter()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 
 mitk::FiberBundleWriter::~FiberBundleWriter()
 {}
 
 
 void mitk::FiberBundleWriter::GenerateData()
 {
   MITK_INFO << "Writing fiber bundle";
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == NULL)
   {
       itkWarningMacro(<<"Sorry, input to FiberBundleWriter is NULL!");
       return;
   }
   if ( m_FileName == "" )
   {
       itkWarningMacro( << "Sorry, filename has not been set!" );
       return ;
   }
 
   std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
   ext = itksys::SystemTools::LowerCase(ext);
 
   if (ext == ".fib")
   {
     /* direct linked includes of mitkFiberBundle DataStructure */
     typedef mitk::FiberBundle::ContainerPointType   ContainerPointType;
     typedef mitk::FiberBundle::ContainerTractType   ContainerTractType;
     typedef mitk::FiberBundle::ContainerType        ContainerType;
 
     ContainerType::Pointer tractContainer = input->GetTractContainer();
     mitk::Geometry3D* geometry = input->GetGeometry();
 
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" ); // TODO what to write here? encoding? etc....
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement(mitk::FiberBundleWriter::XML_FIBER_BUNDLE_FILE);
     mainXML->SetAttribute(mitk::FiberBundleWriter::XML_FILE_VERSION,  mitk::FiberBundleWriter::VERSION_STRING);
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* geometryXML = new TiXmlElement(mitk::FiberBundleWriter::XML_GEOMETRY);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_XX, geometry->GetMatrixColumn(0)[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_XY, geometry->GetMatrixColumn(0)[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_XZ, geometry->GetMatrixColumn(0)[2]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_YX, geometry->GetMatrixColumn(1)[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_YY, geometry->GetMatrixColumn(1)[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_YZ, geometry->GetMatrixColumn(1)[2]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_ZX, geometry->GetMatrixColumn(2)[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_ZY, geometry->GetMatrixColumn(2)[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_MATRIX_ZZ, geometry->GetMatrixColumn(2)[2]);
 
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_ORIGIN_X, geometry->GetOrigin()[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_ORIGIN_Y, geometry->GetOrigin()[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_ORIGIN_Z, geometry->GetOrigin()[2]);
 
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SPACING_X, geometry->GetSpacing()[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SPACING_Y, geometry->GetSpacing()[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SPACING_Z, geometry->GetSpacing()[2]);
 
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SIZE_X, input->GetBounds()[0]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SIZE_Y, input->GetBounds()[1]);
     geometryXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_SIZE_Z, input->GetBounds()[2]);
 
     mainXML->LinkEndChild(geometryXML);
 
     TiXmlElement* fiberBundleXML = new TiXmlElement(mitk::FiberBundleWriter::XML_FIBER_BUNDLE);
     fiberBundleXML->SetAttribute(mitk::FiberBundleWriter::XML_NUM_FIBERS, tractContainer->size());
     int numParticles = 0;
     for (int i=0; i<tractContainer->Size(); i++)
     {
       ContainerTractType::Pointer tract = tractContainer->GetElement(i);
       TiXmlElement* fiberXML = new TiXmlElement(mitk::FiberBundleWriter::XML_FIBER);
       fiberXML->SetAttribute(mitk::FiberBundleWriter::XML_ID, i);
       fiberXML->SetAttribute(mitk::FiberBundleWriter::XML_NUM_PARTICLES, tract->Size());
       numParticles += tract->Size();
       for (int j=0; j<tract->Size(); j++)
       {
         TiXmlElement* particleXML = new TiXmlElement(mitk::FiberBundleWriter::XML_PARTICLE);
         ContainerPointType p = tract->GetElement(j);
         particleXML->SetAttribute(mitk::FiberBundleWriter::XML_ID, j);
         particleXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_POS_X, p[0]);
         particleXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_POS_Y, p[1]);
         particleXML->SetDoubleAttribute(mitk::FiberBundleWriter::XML_POS_Z, p[2]);
         fiberXML->LinkEndChild(particleXML);
       }
       fiberBundleXML->LinkEndChild(fiberXML);
     }
     fiberBundleXML->SetAttribute(mitk::FiberBundleWriter::XML_NUM_PARTICLES, numParticles);
     mainXML->LinkEndChild(fiberBundleXML);
 
     documentXML.SaveFile( m_FileName );
 
     m_Success = true;
 
     MITK_INFO << "Fiber bundle written";
 
   }else if (ext == ".afib" || ext == ".vtk") {
     vtkPolyDataWriter* writer = vtkPolyDataWriter::New();
     writer->SetInput(input->GeneratePolydata());
     writer->SetFileName(m_FileName.c_str());
     writer->SetFileTypeToASCII();
     writer->Write();
 
     m_Success = true;
     MITK_INFO << "Fiber bundle written as polydata";
   }
 
 }
 
 
-void mitk::FiberBundleWriter::SetInput( InputType* diffVolumes )
+void mitk::FiberBundleWriter::SetInputFiberBundle( InputType* diffVolumes )
 {
     this->ProcessObject::SetNthInput( 0, diffVolumes );
 }
 
 
 mitk::FiberBundle* mitk::FiberBundleWriter::GetInput()
 {
     if ( this->GetNumberOfInputs() < 1 )
     {
         return NULL;
     }
     else
     {
         return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
     }
 }
 
 
 std::vector<std::string> mitk::FiberBundleWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".fib");
   possibleFileExtensions.push_back(".afib");
   possibleFileExtensions.push_back(".vtk");
   return possibleFileExtensions;
 }
diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.h b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.h
index 6c1cb911ac..a62a55601d 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.h
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundleWriter.h
@@ -1,216 +1,216 @@
 /*=========================================================================
 
 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 __mitkFiberBundleWriter_h
 #define __mitkFiberBundleWriter_h
 
 #include <itkProcessObject.h>
 #include <mitkFileWriterWithInformation.h>
 #include "mitkFiberBundle.h"
 #include <vtkPolyDataWriter.h>
 
 
 namespace mitk
 {
 
 /**
  * Writes fiber bundles to a file
  * @ingroup Process
  */
 class FiberBundleWriter : public mitk::FileWriterWithInformation
 {
 public:
 
     mitkClassMacro( FiberBundleWriter, mitk::FileWriterWithInformation );
 
     //mitkWriterMacro;
 
     virtual void Write()
     {
       if ( this->GetInput() == NULL )
     {
       itkExceptionMacro(<<"Write:Please specify an input!");
       return;
     }
     /* Fill in image information.*/
       this->UpdateOutputInformation();
       (*(this->GetInputs().begin()))->SetRequestedRegionToLargestPossibleRegion();
       this->PropagateRequestedRegion(NULL);
       this->UpdateOutputData(NULL);
     }
 
     virtual void Update()
     {
       Write();
     }
 
     itkNewMacro( Self );
 
     typedef mitk::FiberBundle InputType;
 
     /**
      * Sets the filename of the file to write.
      * @param FileName the name 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 );
 
     /**
      * Sets the input object for the filter.
      * @param input the diffusion volumes to write to file.
      */
-    void SetInput( InputType* input );
+    void SetInputFiberBundle( 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 "FiberBundle.fib"; }
     virtual const char * GetFileDialogPattern() { return "Fiber Bundle (*.fib *.afib *.vtk)"; }
     virtual const char * GetDefaultExtension() { return ".fib"; }
     virtual bool CanWriteBaseDataType(BaseData::Pointer data) { return (dynamic_cast<mitk::FiberBundle*>(data.GetPointer()) != NULL); };
     virtual void DoWrite(BaseData::Pointer data) {
       if (CanWriteBaseDataType(data)) {
-        this->SetInput(dynamic_cast<mitk::FiberBundle*>(data.GetPointer()));
+        this->SetInputFiberBundle(dynamic_cast<mitk::FiberBundle*>(data.GetPointer()));
         this->Update();
       }
     };
 
     static const char* XML_GEOMETRY;
 
     static const char* XML_MATRIX_XX;
 
     static const char* XML_MATRIX_XY;
 
     static const char* XML_MATRIX_XZ;
 
     static const char* XML_MATRIX_YX;
 
     static const char* XML_MATRIX_YY;
 
     static const char* XML_MATRIX_YZ;
 
     static const char* XML_MATRIX_ZX;
 
     static const char* XML_MATRIX_ZY;
 
     static const char* XML_MATRIX_ZZ;
 
     static const char* XML_ORIGIN_X;
 
     static const char* XML_ORIGIN_Y;
 
     static const char* XML_ORIGIN_Z;
 
     static const char* XML_SPACING_X;
 
     static const char* XML_SPACING_Y;
 
     static const char* XML_SPACING_Z;
 
     static const char* XML_SIZE_X;
 
     static const char* XML_SIZE_Y;
 
     static const char* XML_SIZE_Z;
 
     static const char* XML_FIBER_BUNDLE;
 
     static const char* XML_FIBER;
 
     static const char* XML_PARTICLE;
 
     static const char* XML_ID;
 
     static const char* XML_POS_X;
 
     static const char* XML_POS_Y;
 
     static const char* XML_POS_Z;
 
     static const char* VERSION_STRING;
 
     static const char* XML_FIBER_BUNDLE_FILE;
 
     static const char* XML_FILE_VERSION;
 
     static const char* XML_NUM_FIBERS;
 
     static const char* XML_NUM_PARTICLES;
 
     static const char* ASCII_FILE;
 
     static const char* FILE_NAME;
 
 protected:
 
     FiberBundleWriter();
 
     virtual ~FiberBundleWriter();
 
     virtual void GenerateData();
 
     std::string m_FileName;
 
     std::string m_FilePrefix;
 
     std::string m_FilePattern;
 
     bool m_Success;
 
 };
 
 
 } // end of namespace mitk
 
 #endif //__mitkFiberBundleWriter_h