diff --git a/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.cpp
index b909578354..b0b5609893 100644
--- a/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,335 +1,334 @@
 /*=========================================================================
 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 "itkTractsToDWIImageFilter.h"
 #include "math.h"
 #include "vtkActor.h"
 #include <vtkSmartPointer.h>
 
 struct LessDereference {
   template <class T>
       bool operator()(const T * lhs, const T * rhs) const {
     return *lhs < *rhs;
   }
 };
 
 namespace itk
 {
   TractsToDWIImageFilter::TractsToDWIImageFilter()
   {
     this->SetNumberOfRequiredInputs(1);
   }
 
   TractsToDWIImageFilter::~TractsToDWIImageFilter()
   {
   }
 
   void TractsToDWIImageFilter::GenerateParticleGrid()
   {
     MITK_INFO << "Generating particle grid from fiber bundle";
     m_ParticleGrid = mitk::ParticleGrid::New();
 
     float* bounds = m_FiberBundle->GetBounds();
     int size[] = {(int)bounds[0],(int)bounds[1],(int)bounds[2]};
     m_ParticleGrid->SetSize(size);
 
     typedef itk::Point<float,3>                                                   ContainerPointType; //no need to init, is no smartpointer
     typedef itk::VectorContainer<unsigned int, ContainerPointType>                ContainerTractType;
     typedef itk::VectorContainer< unsigned int, ContainerTractType::Pointer >     ContainerType; //init via smartpointer
 
     ContainerType::Pointer tractContainer = m_FiberBundle->GetTractContainer();
 
     for (int i=0; i<tractContainer->Size(); i++)
     {
       ContainerTractType::Pointer tract = tractContainer->GetElement(i);
       for (int j=0; j<tract->Size(); j++)
       {
         vnl_vector_fixed<float,3> pos = tract->GetElement(j).GetVnlVector();
         vnl_vector_fixed<float,3> next;
         vnl_vector_fixed<float,3> dir;
 
         if (j<tract->Size()-1)
           next = tract->GetElement(j+1).GetVnlVector();
         else
           next = tract->GetElement(j-1).GetVnlVector();
 
         dir = next-pos;
         dir.normalize();
         mitk::Particle* p = new mitk::Particle();
         p->SetPosition(pos);
         p->SetDirection(dir);
         m_ParticleGrid->AddParticle(p);
       }
     }
   }
 
   void TractsToDWIImageFilter::GenerateData()
   {
 
     DWIImageType::Pointer originalDwiImage = dynamic_cast<DWIImageType*>(this->ProcessObject::GetInput(0));
     if (originalDwiImage.IsNull())
     {
       MITK_INFO << "no dwi image to extract b0 specified";
       return;
     }
     short* originalDwiImageBuffer = (short*) originalDwiImage->GetBufferPointer();
 
     if (this->m_FiberBundle.IsNotNull())
       this->GenerateParticleGrid();
     else
     {
       MITK_INFO << "no fiber bundle specified";
       return;
     }
 
     MITK_INFO << "reconstructing dwi-image from particle grid";
 
     float* bounds = m_FiberBundle->GetBounds();
     ImageRegion<3> region;
     region.SetSize(0, bounds[0]);
     region.SetSize(1, bounds[1]);
     region.SetSize(2, bounds[2]);
 
     m_Size[0] = bounds[0];
     m_Size[1] = bounds[1];
     m_Size[2] = bounds[2];
 
     mitk::Geometry3D::Pointer geom = this->m_FiberBundle->GetGeometry();
 
     int numDirections = m_GradientDirections->Size();
     int notNullDirections = 0;
     for (int i=0; i<numDirections; i++){
       GradientDirectionType dir = m_GradientDirections->GetElement(i);
       if (dir[0]!=0 || dir[1]!=0 || dir[2]!=0)
         notNullDirections++;
     }
     MITK_INFO << "Gradient directions: " << notNullDirections;
     MITK_INFO << "B0 images: " << numDirections-notNullDirections;
 
 //    short *averageImageBuffer = new short[m_Size[0]*m_Size[1]*m_Size[2]];
 //    for (int x=0; x<m_Size[0]; x++)
 //      for (int y=0; y<m_Size[1]; y++)
 //        for (int z=0; z<m_Size[2]; z++)
 //        {
 //          short val = 0;
 //          for(unsigned int i=0; i<numDirections; i++)
 //          {
 //            int index = i + (x + m_Size[0]*(y+m_Size[1]*z))*numDirections;
 
 //            GradientDirectionType dir = m_GradientDirections->GetElement(i);
 //            if (dir[0]!=0 || dir[1]!=0 || dir[2]!=0)
 //              val += originalDwiImageBuffer[index];
 //          }
 //          averageImageBuffer[x + m_Size[0]*(y+m_Size[1]*z)] = (short)val/notNullDirections;
 //        }
 
     // allocate output image
     m_OutImage = static_cast< DWIImageType* >(this->ProcessObject::GetOutput(0));
     m_OutImage->SetSpacing( geom->GetSpacing() );   // Set the image spacing
     m_OutImage->SetOrigin( geom->GetOrigin() );     // Set the image origin
     itk::Matrix<double, 3, 3> matrix;
     for (int i=0; i<3; i++)
       for (int j=0; j<3; j++)
         matrix[j][i] = geom->GetMatrixColumn(i)[j];
     m_OutImage->SetDirection( matrix );  // Set the image direction
     m_OutImage->SetRegions( region );  // Set image region
     m_OutImage->SetVectorLength( numDirections );
     m_OutImage->Allocate();
 
     short* imageBuffer = (short*) m_OutImage->GetBufferPointer();
 
     m_BesselApproxCoeff = this->ComputeFiberCorrelation();
 
     int dist = 1;
     if (this->m_ParticleWidth==0)
     {
       double voxsize[3];
       voxsize[0] = geom->GetSpacing().GetElement(0);
       voxsize[1] = geom->GetSpacing().GetElement(1);
       voxsize[2] = geom->GetSpacing().GetElement(2);
       float vox_half;
       if(voxsize[0]<voxsize[1] && voxsize[0]<voxsize[2])
         vox_half = voxsize[0] / 2.0;
       else if (voxsize[1] < voxsize[2])
         vox_half = voxsize[1] / 2.0;
       else
         vox_half = voxsize[2] / 2.0;
       m_ParticleWidth = 0.5*vox_half;
     }
     float width = this->m_ParticleWidth*this->m_ParticleWidth;
 
     int bufferSize = m_Size[0]*m_Size[1]*m_Size[2]*numDirections;
     int counter = 0;
     short maxVal = 0;
 
     for (int x=0; x<m_Size[0]; x++)
       for (int y=0; y<m_Size[1]; y++)
         for (int z=0; z<m_Size[2]; z++)
         {
           vnl_vector_fixed<float, 3> pos;
           pos[0] = (float)x;
           pos[1] = (float)y;
           pos[2] = (float)z;
           for(unsigned int i=0; i<numDirections; i++)
           {
             int index = i + (x + m_Size[0]*(y+m_Size[1]*z))*numDirections;
             float val = 0;
 
             if (i>=notNullDirections){
               imageBuffer[index] = originalDwiImageBuffer[index];
               continue;
             }
 
             vnl_vector_fixed<double, 3> temp = m_GradientDirections->GetElement(i);
 
             // gradient direction
             vnl_vector_fixed<float, 3> n;
             n[0] = temp[0];
             n[1] = temp[1];
             n[2] = temp[2];
 
             for (int nx=-dist; nx<=dist; nx++)
               if((x+nx)>=0 && (x+nx)<m_Size[0])
               for (int ny=-dist; ny<=dist; ny++)
               if((y+ny)>=0 && (y+ny)<m_Size[1])
                 for (int nz=-dist; nz<=dist; nz++)
                 if((z+nz)>=0 && (z+nz)<m_Size[2]){
                   ParticleContainerType::Pointer container = m_ParticleGrid->GetParticleContainer(x+nx, y+ny, z+nz);
                   if(container.IsNotNull())
                   for (int j=0; j<container->Size(); j++)
                   {
                     mitk::Particle* particle = container->GetElement(j);
                     // Particle direction
                     vnl_vector_fixed<float, 3> ni = particle->GetDirection();
                     // Particle position
                     vnl_vector_fixed<float, 3> xi = particle->GetPosition();
 
                     vnl_vector_fixed<float, 3> diff = pos-xi;
                     float angle = fabs(dot_product(n, ni));
 
                     val += std::exp(-diff.squared_magnitude()/width)*(std::exp(-m_bD*angle*angle));
                   }
                 }
             //MITK_INFO << val; averageImageBuffer[x + m_Size[0]*(y+m_Size[1]*z)]
             imageBuffer[index] = (short)(val*100+1);
             if (counter%((int)(bufferSize/10))==0)
               MITK_INFO << 100*counter/bufferSize << "%";
             counter++;
             if (imageBuffer[index] > maxVal)
               maxVal = imageBuffer[index];
           }
         }
     //delete(averageImageBuffer);
     for (int x=0; x<m_Size[0]; x++)
       for (int y=0; y<m_Size[1]; y++)
         for (int z=0; z<m_Size[2]; z++)
         {
           for(unsigned int i=0; i<numDirections; i++)
           {
             int index = i + (x + m_Size[0]*(y+m_Size[1]*z))*numDirections;
             if (i>=notNullDirections){
               imageBuffer[index] += maxVal;
               continue;
             }
           }
         }
   }
 
   float TractsToDWIImageFilter::Bessel(float x)
   {
     float y = x*x;
     float z = y*y;
     float erg = m_BesselApproxCoeff[0];
     erg += y*m_BesselApproxCoeff[1];
     erg += z*m_BesselApproxCoeff[2];
     erg += z*y*m_BesselApproxCoeff[3];
     return erg;
   }
 
   float* TractsToDWIImageFilter::ComputeFiberCorrelation(){
 
     float bD = m_bD;
 
     vnl_matrix_fixed<double, 3, QBALL_ODFSIZE> bDir =
         *itk::PointShell<QBALL_ODFSIZE, vnl_matrix_fixed<double, 3, QBALL_ODFSIZE> >::DistributePointShell();
 
     const int N = QBALL_ODFSIZE;
 
     vnl_matrix_fixed<double, N, N> C = bDir.transpose()*bDir;
     vnl_matrix_fixed<double, N, N> Q = C;
     for(int i=0; i<N; i++)
     {
       for(int j=0; j<N; j++)
       {
         C(i,j) = std::abs(C(i,j));
         Q(i,j) = exp(-bD * C(i,j) * C(i,j));
       }
     }
 
     vnl_matrix_fixed<double, N, N> P = Q*Q;
 
     std::vector<const double *> pointer;
     pointer.reserve(N*N);
     double * start = C.data_block();
     double * end =  start + N*N;
     for (double * iter = start; iter != end; ++iter)
     {
       pointer.push_back(iter);
     }
     std::sort(pointer.begin(), pointer.end(), LessDereference());
 
     vnl_vector_fixed<double,N*N> alpha;
     vnl_vector_fixed<double,N*N> beta;
     for (int i=0; i<N*N; i++) {
       alpha(i) = *pointer[i];
       beta(i)  = *(P.data_block()+(pointer[i]-start));
     }
 
     double nfac = sqrt(beta(N*N-1));
     beta = beta / (nfac*nfac);
     Q = Q / nfac;
 
     double sum = 0;
     for(int i=0; i<N; i++)
     {
       sum += Q(0,i);
     }
     // if left to default 0
     // then mean is not substracted in order to correct odf integral
     this->m_Meanval_sq = (sum*sum)/N;
 
     vnl_vector_fixed<double,N*N> alpha_0;
     vnl_vector_fixed<double,N*N> alpha_2;
     vnl_vector_fixed<double,N*N> alpha_4;
     vnl_vector_fixed<double,N*N> alpha_6;
     for(int i=0; i<N*N; i++)
     {
       alpha_0(i) = 1;
       alpha_2(i) = alpha(i)*alpha(i);
       alpha_4(i) = alpha_2(i)*alpha_2(i);
       alpha_6(i) = alpha_4(i)*alpha_2(i);
     }
 
     vnl_matrix_fixed<double, N*N, 4> T;
     T.set_column(0,alpha_0);
     T.set_column(1,alpha_2);
     T.set_column(2,alpha_4);
     T.set_column(3,alpha_6);
 
     vnl_vector_fixed<double,4> coeff = vnl_matrix_inverse<double>(T).pinverse()*beta;
 
     float* retval = new float[4];
     retval[0] = coeff(0);
     retval[1] = coeff(1);
     retval[2] = coeff(2);
     retval[3] = coeff(3);
     return retval;
   }
 }
diff --git a/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.h
index c39faed42a..89c0f74a17 100644
--- a/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,105 +1,108 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 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 __itkTractsToDWIImageFilter_h__
 #define __itkTractsToDWIImageFilter_h__
 
 // MITK
 #include <mitkParticle.h>
 #include <mitkParticleGrid.h>
 #include <mitkFiberBundle.h>
 
 // ITK
 #include <itkImage.h>
 #include <itkProcessObject.h>
 #include <itkImageToImageFilter.h>
 #include <itkOrientationDistributionFunction.h>
 
 typedef itk::VectorImage< short, 3 > DWIImageType;
 
 namespace itk
 {
   class TractsToDWIImageFilter :
       public ImageToImageFilter< DWIImageType, DWIImageType >{
 
   public:
     typedef TractsToDWIImageFilter Self;
     typedef ImageToImageFilter< DWIImageType, DWIImageType > Superclass;
     typedef SmartPointer< Self > Pointer;
     typedef SmartPointer< const Self > ConstPointer;
 
     typedef itk::VectorContainer< int, mitk::Particle* > ParticleContainerType;
     typedef mitk::ParticleGrid::Pointer ParticleGridType;
 
     typedef mitk::FiberBundle::Pointer FiberBundleType;
 
     typedef vnl_vector_fixed< double, 3 > GradientDirectionType;
     typedef itk::VectorContainer< unsigned int,  GradientDirectionType > GradientDirectionContainerType;
 
     itkNewMacro(Self);
     itkTypeMacro( TractsToDWIImageFilter, ImageToImageFilter );
 
     // odf type
     typedef OrientationDistributionFunction<float, QBALL_ODFSIZE> OdfType;
 
     itkSetMacro(FiberBundle, FiberBundleType);
     itkGetMacro(FiberBundle, FiberBundleType);
 
     itkSetMacro(ParticleGrid, ParticleGridType);
     itkGetMacro(ParticleGrid, ParticleGridType);
 
     itkSetMacro(bD, int);
     itkGetMacro(bD, int);
 
     itkSetMacro(ParticleWidth, float);
     itkGetMacro(ParticleWidth, float);
 
     itkSetMacro(ParticleLength, float);
     itkGetMacro(ParticleLength, float);
 
     itkSetMacro(ParticleWeight, float);
     itkGetMacro(ParticleWeight, float);
 
     itkSetMacro(GradientDirections, GradientDirectionContainerType::Pointer);
     itkGetMacro(GradientDirections, GradientDirectionContainerType::Pointer);
 
     void GenerateData();
 
   protected:
 
     TractsToDWIImageFilter();
     virtual ~TractsToDWIImageFilter();
 
     GradientDirectionContainerType::Pointer m_GradientDirections;
     FiberBundleType m_FiberBundle;
     ParticleGridType m_ParticleGrid;
     DWIImageType::Pointer m_OutImage;
     int m_Size[3];
     float m_Meanval_sq;
 
     float *m_BesselApproxCoeff;
     float* ComputeFiberCorrelation();
     float Bessel(float x);
     void GenerateParticleGrid();
 
     int m_bD;
     float m_ParticleWidth;
     float m_ParticleLength;
     float m_ParticleWeight;
   };
 }
+
+#include "itkTractsToDWIImageFilter.cpp"
+
 #endif
diff --git a/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h b/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
index d7ecb2fb05..2191525e52 100644
--- a/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
+++ b/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
@@ -1,79 +1,78 @@
 /*=========================================================================
 
 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_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
 #define _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
 
 #include "mitkImageSource.h"
-#include "MitkDiffusionImagingExports.h"
 
 namespace mitk {
 
   template<typename TPixelType>
   class DiffusionImage;
   /*class DiffusionImage<double>;
   class DiffusionImage<int>;
   class DiffusionImage<unsigned int>;
   class DiffusionImage<short>;
   class DiffusionImage<unsigned short>;
   class DiffusionImage<char>;
   class DiffusionImage<unsigned char>;
   class DiffusionImage<long>;
   class DiffusionImage<unsigned long>;*/
 
 //##Documentation
 //## @brief Superclass of all classes generating diffusion volumes (instances 
 //## of class DiffusionImage) as output. 
 //##
 //## @ingroup Process
 template<typename TPixelType>
-class MitkDiffusionImaging_EXPORT DiffusionImageSource : public ImageSource
+class DiffusionImageSource : public ImageSource
 {
 public:
   mitkClassMacro(DiffusionImageSource, BaseProcess);
   itkNewMacro(Self);  
 
   typedef DiffusionImage<TPixelType> OutputType;
   typedef itk::DataObject::Pointer DataObjectPointer;
 
   virtual DataObjectPointer MakeOutput(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:
   DiffusionImageSource();
 
   virtual ~DiffusionImageSource();
 };
 
 } // namespace mitk
 
 #include "mitkDiffusionImageSource.cpp"
 
 
 #endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundle.h b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundle.h
index 23602f500f..b588b83e36 100644
--- a/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundle.h
+++ b/Modules/DiffusionImaging/IODataStructures/FiberBundle/mitkFiberBundle.h
@@ -1,198 +1,196 @@
 
 /*=========================================================================
 
  Program:   Medical Imaging & Interaction Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  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 _MITK_FiberBundle_H
 #define _MITK_FiberBundle_H
 
 //includes for MITK datastructure
 #include "mitkBaseData.h"
 #include "MitkDiffusionImagingExports.h"
 
 //=======modernized================
 //includes storing fiberdata
 #include <vtkSmartPointer.h> //may be replaced by class precompile argument
 #include <vtkPolyData.h> // may be replaced by class
 #include <vtkPoints.h> // my be replaced by class
 
 
 //includes processing of fibers
 //
 //=========modernized end===========
 
 
 #include "mitkPlanarFigure.h"
 
 /* This Class represents a bunch of FiberTracts as a Bundle.
  A Bundle is represented by a GroupSpatialObject */
 
 #include "itkDTITubeSpatialObject.h"
 #include "itkDTITubeSpatialObjectPoint.h"
 #include "itkGroupSpatialObject.h"
 #include "itkPolyLineParametricPath.h"
 #include "itkSlowPolyLineParametricPath.h"
 #include "itkVectorContainer.h"
 #include "itkPointSet.h"
 #include "itkVector.h"
 #include <vtkCell.h>
 //#include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkDoubleArray.h>
 #include <vtkPolyLine.h>
 #include <vtkVertex.h>
 #include <vtkPointData.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
   /**
    * \brief Base Class for Fiber Bundles;   */
   class  MitkDiffusionImaging_EXPORT FiberBundle : public BaseData
   {
+  public:
 
     /* friend classes wanna access typedefs
-      ContainerPointType, ContainerTractType, ContainerType */
+    ContainerPointType, ContainerTractType, ContainerType */
     friend class FiberBundleWriter;
     friend class FiberBundleReader;
-//    friend class itkTractsToDWIImageFilter;
+    //    friend class itkTractsToDWIImageFilter;
 
     /** Types for the standardized TractContainer **/
     typedef itk::Point<float,3>                                                   ContainerPointType; //no need to init, is no smartpointer
     typedef itk::VectorContainer<unsigned int, ContainerPointType>                ContainerTractType;
     typedef itk::VectorContainer< unsigned int, ContainerTractType::Pointer >     ContainerType; //init via smartpointer
 
 
 
     /** Types for the ITK Stochastic TractContainer **/
     typedef itk::SlowPolyLineParametricPath< 3 >  itkStochTractType;
     typedef itk::VectorContainer< unsigned int, itkStochTractType::Pointer > itkStochTractContainerType;
 
 
     // virtual methods that need to be implemented
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion( itk::DataObject *data );
 
-
-  public:
-
     static const int TRACTPOINT_BACKFACE;
     static const int TRACTPOINT_ON_PLANE;
     static const int TRACTPOINT_FRNTFACE;
 
 
     /* DTITubeSpatialObject Definitions */
     typedef itk::GroupSpatialObject<3>        FiberGroupType;
     typedef FiberGroupType::ChildrenListType  ChildrenListType;
 
     typedef itk::DTITubeSpatialObject<3>       DTITubeType;
     typedef itk::DTITubeSpatialObjectPoint<3>  DTITubePointType;
 
     mitkClassMacro( FiberBundle, BaseData );
     itkNewMacro( Self );
 
 
    /* Handle Output Type of ITK Stochastic Tractography Fiber Tracking */
     void addTractContainer( ContainerType::Pointer );
     void additkStochTractContainer(itkStochTractContainerType::Pointer);
     void initFiberGroup();
     void addSingleDTITract(mitk::FiberBundle::DTITubeType::Pointer);
     DTITubeType::Pointer copySingleDTITract(DTITubeType::Pointer);
 
     /* Methods for PlanarFigure ROIs */
     //mitk::FiberBundle::Pointer extractFibersPF(mitk::PlanarFigure::Pointer);
     std::vector<int> extractFibersByPF(mitk::PlanarFigure::Pointer, std::vector<int>* set=0);
     mitk::FiberBundle::Pointer extractFibersById(std::vector<int> );
     std::vector<int> getAllIDsInFiberBundle();
 
 
     mitk::Point3D calculateCrossingPoint(mitk::Point3D , mitk::Point3D , mitk::PlanarFigure::Pointer ); //depricated
     bool checkForGap(int, int); //depricated
     /*********************************/
 
 
     void debug_members();
 
     void SetBounds(float* b);
     void SetBounds(double* b);
     float* GetBounds();
 
 
 
 //****  REALTIME MONITOR CONTAINER METHOD ****//
     //flag overwrite existing bundle
     void addContainer4speedDisplay( ContainerType::Pointer );
 
     itkGetMacro(GroupFiberBundle, FiberGroupType::Pointer);
     itkGetMacro(TractContainer, ContainerType::Pointer);
 
     //** explicit handling of FiberBundleDataStructure contents *//
     void PushPoint(int fiberIndex, ContainerPointType point);
     void PushTract(ContainerTractType::Pointer tract);
     ContainerPointType GetPoint(int tractIndex, int pointIndex);
     ContainerTractType::Pointer GetTract(int tractIndex);
     int GetNumTracts();
     int GetNumPoints(int tractIndex);
     FiberGroupType::Pointer getGroupFiberBundle();
 
     mitk::FiberBundle::Pointer JoinBundle(mitk::FiberBundle::Pointer bundle);
     int FindTractByEndpoints(mitk::FiberBundle::DTITubeType::Pointer searchTract);
     mitk::FiberBundle::Pointer SubstractBundle(mitk::FiberBundle::Pointer bundle);
     void InsertBundle(mitk::FiberBundle::Pointer bundle);
     vtkPolyData* GeneratePolydata();
 
 //    int SearchFiber(worldPoint, tolerance, resultDistance);
 
   protected:
     FiberBundle();
     virtual ~FiberBundle();
 
   private:
 //      =========MODERNIZED==========
 //      The following polydata variables are used for fiber- and pointbased representation of the tractography results. As VTK suggests, one vtkPolyData is used to manage vertices and the other for polylines.
 //      FiberPolyData stores all brain fibers using polylines (in world coordinates)
       vtkSmartPointer<vtkPolyData> m_FiberPolyData;
 
 //      VertexPolyData stores all original points as vertices computed by tracking algorithms
       vtkSmartPointer<vtkPolyData> m_VertexPolyData;
       vtkSmartPointer<vtkPoints>   m_Particles;
       
 //  ===============Moedernized end=====    
     FiberGroupType::Pointer m_GroupFiberBundle;
     ContainerType::Pointer m_TractContainer;
     itkStochTractContainerType::Pointer m_debugITKContainer;
 
     void fiberPostprocessing_FA( DTITubePointType* );
     void fiberPostprocessing_setPoint(DTITubePointType* , ContainerPointType );
     void fiberPostprocessing_setTensorMatrix(DTITubePointType*);
 
     int debug_PrototypeCounter;
     float m_boundsFB[3];
 
     /* Methods for PlanarFigure ROIs */
     bool isPointInSelection(mitk::Point3D, mitk::PlanarFigure::Pointer);
     vtkPolyData* m_PolyData;
 
   };
 
 } // namespace mitk
 
 #endif /*  _MITK_FiberBundle_H */
diff --git a/Modules/DiffusionImaging/files.cmake b/Modules/DiffusionImaging/files.cmake
index cd24c7b1c6..ad2529cc2e 100644
--- a/Modules/DiffusionImaging/files.cmake
+++ b/Modules/DiffusionImaging/files.cmake
@@ -1,123 +1,122 @@
 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 -> PlanarFigureComposite
   IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp
 
 
   # DataStructures -> Tbss  
   IODataStructures/TbssImages/mitkTbssImageSource.cpp  
   IODataStructures/TbssImages/mitkNrrdTbssImageReader.cpp 
   IODataStructures/TbssImages/mitkNrrdTbssImageIOFactory.cpp
   IODataStructures/TbssImages/mitkTbssImage.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
   IODataStructures/TbssImages/mitkNrrdTbssImageWriterFactory.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
 
   # Interactions
   Interactions/mitkFiberBundleInteractor.cpp
 
   # Algorithms
-  Algorithms/itkTractsToDWIImageFilter.cpp
 )
 
 SET(H_FILES
   # Rendering
   Rendering/mitkDiffusionImageMapper.h
   Rendering/mitkOdfVtkMapper2D.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
 
  
   # Tractography
   Tractography/itkGlobalTractographyFilter.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
 )
 
 SET( TOOL_FILES
 )
 
 IF(WIN32)
 ENDIF(WIN32)
 
 #MITK_MULTIPLEX_PICTYPE( Algorithms/mitkImageRegistrationMethod-TYPE.cpp )