diff --git a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
index 0814a20a0d..2a5e9c1684 100644
--- a/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/mitkDiffusionImagingObjectFactory.cpp
@@ -1,434 +1,435 @@
 /*=========================================================================
 
 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"
 #include "mitkTbssGradientImageMapper.h"
 
 //====depricated fiberstructure=====
 #include "mitkFiberBundle.h"
 #include "mitkFiberBundleMapper2D.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 "mitkFiberBundleXMapper2D.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"
 
 
 #include "mitkNrrdTbssGradientImageWriterFactory.h"
 #include "mitkNrrdTbssGradientImageWriter.h"
 
 #include "mitkPlanarCircleMapper3D.h"
 #include "mitkPlanarPolygonMapper3D.h"
 
 
 
 typedef short DiffusionPixelType;
 typedef char TbssRoiPixelType;
 typedef float TbssPixelType;
 typedef int TbssGradientPixelType;
 
 
 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_DEBUG << "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
     mitk::NrrdTbssGradientImageWriterFactory::RegisterOneFactory();
 
     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::New().GetPointer() );
     m_FileWriters.push_back( mitk::FiberBundleXWriter::New().GetPointer() );//modernized
     m_FileWriters.push_back( mitk::NrrdTbssGradientImageWriter::New().GetPointer() );
 
     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);
     }
 
     classname = "TbssRoiImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::ImageVtkMapper2D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::FiberBundleMapper2D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "FiberBundleX";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
-      newMapper = mitk::FiberBundleMapper2D::New();
+      newMapper = mitk::FiberBundleXMapper2D::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssImageMapper::New();
       newMapper->SetDataNode(node);
     }
 
     classname = "TbssGradientImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssGradientImageMapper::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);
     }
     
     classname =  "PlanarCircle";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarCircleMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
     classname = "PlanarPolygon";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::PlanarPolygonMapper3D::New();
       newMapper->SetDataNode(node);
     }
     
 
     classname = "TbssGradientImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::TbssGradientImageMapper::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);
     mitk::FiberBundleMapper2D::SetDefaultProperties(node);
   }
 
   classname = "FiberBundleX";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::FiberBundleXMapper3D::SetDefaultProperties(node);
 //    mitk::FiberBundleXMapper2D::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);
   }
 
   classname = "TbssGradientImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::TbssGradientImageMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
   
   classname = "PlanarCircle";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarCircleMapper3D::SetDefaultProperties(node);
   }
   
   classname = "PlanarPolygon";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::PlanarPolygonMapper3D::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>("*.pf", "Planar Figure File"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 
   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>("*.pf", "Planar Figure File"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.roi", "TBSS ROI data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tgi", "TBSS gradient image"));
 }
 
 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories()
 {
 }
 
 void RegisterDiffusionImagingObjectFactory()
 {
   static bool oneDiffusionImagingObjectFactoryRegistered = false;
   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
     MITK_DEBUG << "Registering DiffusionImagingObjectFactory..." << std::endl;
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
 
     oneDiffusionImagingObjectFactoryRegistered = true;
   }
 }
diff --git a/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
index 038a9d5e47..af932b018b 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
@@ -1,110 +1,110 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2011-01-18 13:22:38 +0100 (Di, 18 Jan 2011) $
 Version:   $Revision: 28959 $
 
 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 "mitkTrackingVolumeGenerator.h"
 #include "mitkSTLFileReader.h"
 #include "mitkStandardFileLocations.h"
 #include "mitkConfig.h"
 #include <vtkCubeSource.h>
 #include <mitkTrackingTypes.h>
 #include <mitkTrackingDevice.h>
 #include <mitkVirtualTrackingDevice.h>
 #include <vtkSmartPointer.h>
 #include <mitkSurface.h>
 
 mitk::TrackingVolumeGenerator::TrackingVolumeGenerator()
 {
     std::string volumeDir = MITK_ROOT;
     volumeDir += "Modules/IGT/IGTTrackingDevices/TrackingVolumeData"; //folder which contains the trackingdevices configs
     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch( volumeDir.c_str(), false ); //add this directory to StdFileLocations for the search
 
 	m_Data = mitk::DeviceDataUnspecified;
 }
 
 
 void mitk::TrackingVolumeGenerator::SetTrackingDevice (mitk::TrackingDevice::Pointer tracker)
 {
 	this->m_Data = mitk::GetFirstCompatibleDeviceDataForLine(tracker->GetType());
 }
 
 void mitk::TrackingVolumeGenerator::GenerateData()
 {
     mitk::Surface::Pointer output = this->GetOutput();  //the surface wich represents the tracking volume
 
-    std::string filepath = ""; // Full path to file
-	std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String like "cube"
+    std::string filepath = ""; // Full path to file (wil be resolved later)
+	std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String, e.g. "cube"
 	
-	// See if filename mathes a magic String.
+	// See if filename matches a magic string.
 	if (filename.compare("cube") == 0){
             vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
             double bounds[6];
             bounds[0] = bounds[2] = bounds[4] = -400.0;  // initialize bounds to -400 ... +400 cube. This is the default value of the
             bounds[1] = bounds[3] = bounds[5] =  400.0;  // virtual tracking device, but it can be changed. In that case,
                                                          // the tracking volume polydata has to be updated manually
             cubeSource->SetBounds(bounds);
             cubeSource->GetOutput()->Update();
 
             output->SetVtkPolyData(cubeSource->GetOutput()); //set the vtkCubeSource as polyData of the surface
             return;
 	} 
 	if (filename.compare("") == 0) // empty String means no model, return empty output
 	{
       output->SetVtkPolyData(vtkPolyData::New()); //initialize with empty poly data (otherwise old surfaces may be returned) => so an empty surface is returned
       return;
 	}
 	
-	// In the following Code, we assume that filename contains an actual filename andn ot a magic string
+	// from here on, we assume that filename contains an actual filename and not a magic string
 
 	filepath = mitk::StandardFileLocations::GetInstance()->FindFile(filename.c_str());
 	
     if (filepath.empty())
     {
-        MITK_ERROR << "Filename is empty";
+        MITK_ERROR << ("Volume Generator could not find the specified file " + filename);
         return;
     }
 
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     stlReader->SetFileName( filepath.c_str() );
     stlReader->Update();
 
     if ( stlReader->GetOutput() == NULL)
     {
         MITK_ERROR << "Error while reading file";
         return ;
     }
     output->SetVtkPolyData( stlReader->GetOutput()->GetVtkPolyData());//set the visible trackingvolume
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceType(mitk::TrackingDeviceType deviceType)
 {
   m_Data = mitk::GetFirstCompatibleDeviceDataForLine(deviceType);
 }
 
 mitk::TrackingDeviceType mitk::TrackingVolumeGenerator::GetTrackingDeviceType() const
 {
  return m_Data.Line;
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceData(mitk::TrackingDeviceData deviceData)
 {
   m_Data= deviceData;
 }
 
 mitk::TrackingDeviceData mitk::TrackingVolumeGenerator::GetTrackingDeviceData() const
 {
    return m_Data;
 }