diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkSurfaceModifier.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkSurfaceModifier.cpp
index 4beb3bb9d0..e1e8e8a528 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkSurfaceModifier.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkSurfaceModifier.cpp
@@ -1,245 +1,245 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // mitk headers
 #include "mitkSurfaceModifier.h"
 #include "mitkSurfaceToPointSetFilter.h"
 
 // vtk headers
 #include <vtkMath.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 mitk::SurfaceModifier::SurfaceModifier()
 {
   m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
 }
 
 mitk::SurfaceModifier::~SurfaceModifier()
 {
 }
 
 mitk::Point3D mitk::SurfaceModifier::PerturbePointAlongAxis(mitk::Point3D point, mitk::Vector3D axis, double variance)
 {
   if (m_myRandomGenerator.IsNull())
     m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
   mitk::Point3D returnValue;
 
   // normalize axis
   mitk::Vector3D normalizedAxis = axis;
   normalizedAxis.Normalize();
 
   // create noise
   double noise = m_myRandomGenerator->GetNormalVariate(0.0, variance);
 
   // std::cout <<point<<std::endl;
   // add noise to point along axis
   returnValue[0] = point[0] + axis[0] * noise;
   returnValue[1] = point[1] + axis[1] * noise;
   returnValue[2] = point[2] + axis[2] * noise;
   // std::cout<<returnValue;
 
   return returnValue;
 }
 
 mitk::Point3D mitk::SurfaceModifier::PerturbePoint(
   mitk::Point3D point, double varianceX, double varianceY, double varianceZ)
 {
   if (m_myRandomGenerator.IsNull())
     m_myRandomGenerator = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
   mitk::Point3D returnValue;
   returnValue[0] = point[0] + m_myRandomGenerator->GetNormalVariate(0.0, varianceX);
   returnValue[1] = point[1] + m_myRandomGenerator->GetNormalVariate(0.0, varianceY);
   returnValue[2] = point[2] + m_myRandomGenerator->GetNormalVariate(0.0, varianceZ);
   return returnValue;
 }
 
 bool mitk::SurfaceModifier::TransformSurface(mitk::Surface::Pointer surface,
                                              itk::Matrix<double, 3, 3> TransformationR,
                                              itk::Vector<double, 3> TransformationT)
 {
   // apply transformation
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
 
-  for (unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+  for (vtkIdType i = 0; i < points->GetNumberOfPoints(); i++)
   {
     double p[3];
     points->GetPoint(i, p);
     mitk::Point3D point;
     point[0] = p[0];
     point[1] = p[1];
     point[2] = p[2];
     point = TransformPoint(point, TransformationR, TransformationT);
     p[0] = point[0];
     p[1] = point[1];
     p[2] = point[2];
     points->SetPoint(i, p);
   }
   surface->GetVtkPolyData()->SetPoints(points);
 
   return true;
 }
 
 bool mitk::SurfaceModifier::TransformSurfaceCoGCoordinates(mitk::Surface::Pointer surface,
                                                            itk::Matrix<double, 3, 3> TransformationR,
                                                            itk::Vector<double, 3> TransformationT,
                                                            itk::Matrix<double, 3, 3> &OverallTransformationR,
                                                            itk::Vector<double, 3> &OverallTransformationT)
 {
   // initialize return values
   OverallTransformationR.SetIdentity();
   OverallTransformationT.Fill(0);
 
   // move surface to center of gravity and store transformation
   itk::Matrix<double, 3, 3> TransformRToCenter;
   itk::Vector<double, 3> TransformTToCenter;
   MoveSurfaceToCenter(surface, TransformRToCenter, TransformTToCenter);
 
   OverallTransformationR = TransformRToCenter;
   OverallTransformationT = TransformTToCenter;
 
   // apply transformation
   TransformSurface(surface, TransformationR, TransformationT);
 
   OverallTransformationR = TransformationR * OverallTransformationR;
   OverallTransformationT = (TransformationR * OverallTransformationT) + TransformationT;
 
   // move surface back to original position (build inverse transformation andy apply it)
   TransformRToCenter = TransformRToCenter.GetInverse();
   TransformTToCenter = (TransformRToCenter * TransformTToCenter) * -1.;
   TransformSurface(surface, TransformRToCenter, TransformTToCenter);
 
   OverallTransformationR = TransformRToCenter * OverallTransformationR;
   OverallTransformationT = (TransformRToCenter * OverallTransformationT) + TransformTToCenter;
 
   return true;
 }
 
 mitk::Point3D mitk::SurfaceModifier::TransformPoint(mitk::Point3D point,
                                                     itk::Matrix<double, 3, 3> TransformationR,
                                                     itk::Vector<double, 3> TransformationT)
 {
   mitk::Point3D returnValue = TransformationR * point + TransformationT;
   return returnValue;
 }
 
 bool mitk::SurfaceModifier::AddOutlierToSurface(
   mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double outlierChance)
 {
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
-  for (unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+  for (vtkIdType i = 0; i < points->GetNumberOfPoints(); i++)
   {
     double p[3];
     points->GetPoint(i, p);
     mitk::Point3D point;
     point[0] = p[0];
     point[1] = p[1];
     point[2] = p[2];
     if ((outlierChance - vtkMath::Random(0, 1)) > 0)
       point = PerturbePoint(point, varianceX, varianceY, varianceZ);
     p[0] = point[0];
     p[1] = point[1];
     p[2] = point[2];
     points->SetPoint(i, p);
   }
   surface->GetVtkPolyData()->SetPoints(points);
   return true;
 }
 
 bool mitk::SurfaceModifier::PerturbeSurface(
   mitk::Surface::Pointer surface, double varianceX, double varianceY, double varianceZ, double)
 {
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->ShallowCopy(surface->GetVtkPolyData()->GetPoints());
-  for (unsigned int i = 0; i < points->GetNumberOfPoints(); i++)
+  for (vtkIdType i = 0; i < points->GetNumberOfPoints(); i++)
   {
     double p[3];
     points->GetPoint(i, p);
     mitk::Point3D point;
     point[0] = p[0];
     point[1] = p[1];
     point[2] = p[2];
     point = PerturbePoint(point, varianceX, varianceY, varianceZ);
     p[0] = point[0];
     p[1] = point[1];
     p[2] = point[2];
     points->SetPoint(i, p);
   }
   surface->GetVtkPolyData()->SetPoints(points);
 
   return true;
 }
 
 bool mitk::SurfaceModifier::MoveSurfaceToCenter(mitk::Surface::Pointer surface)
 {
   itk::Matrix<double, 3, 3> dummyR;
   itk::Vector<double, 3> dummyT;
   return MoveSurfaceToCenter(surface, dummyR, dummyT);
 }
 
 bool mitk::SurfaceModifier::MoveSurfaceToCenter(mitk::Surface::Pointer surface,
                                                 itk::Matrix<double, 3, 3> &TransformR,
                                                 itk::Vector<double, 3> &TransformT)
 {
   // get center of cravity
   mitk::Point3D CoG = GetCenterOfGravity(surface);
 
   // initialize transforms
   TransformR.SetIdentity();
   TransformT.Fill(0);
   TransformT[0] = -CoG[0];
   TransformT[1] = -CoG[1];
   TransformT[2] = -CoG[2];
 
   // apply transform
   return TransformSurface(surface, TransformR, TransformT);
 }
 
 mitk::Point3D mitk::SurfaceModifier::GetCenterOfGravity(mitk::Surface::Pointer surface)
 {
   // convert surface to point set
   mitk::SurfaceToPointSetFilter::Pointer myConverter = mitk::SurfaceToPointSetFilter::New();
   myConverter->SetInput(surface);
   myConverter->Update();
   mitk::PointSet::Pointer pointSet = myConverter->GetOutput();
 
   // calculate center of gravity
   mitk::Point3D cog;
   cog.Fill(0);
   for (int i = 0; i < pointSet->GetSize(); i++)
   {
     cog[0] += pointSet->GetPoint(i)[0];
     cog[1] += pointSet->GetPoint(i)[1];
     cog[2] += pointSet->GetPoint(i)[2];
   }
   cog[0] /= pointSet->GetSize();
   cog[1] /= pointSet->GetSize();
   cog[2] /= pointSet->GetSize();
 
   return cog;
 }
 
 mitk::Surface::Pointer mitk::SurfaceModifier::DeepCopy(mitk::Surface::Pointer originalSurface)
 {
   mitk::Surface::Pointer clonedSurface = mitk::Surface::New();
   vtkSmartPointer<vtkPolyData> clonedPolyData = vtkSmartPointer<vtkPolyData>::New();
   clonedPolyData->DeepCopy(originalSurface->GetVtkPolyData());
   clonedSurface->SetVtkPolyData(clonedPolyData);
   return clonedSurface;
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp
index 21e29a1ca1..f03702b210 100644
--- a/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.imaging/src/internal/surfaceutilities/mitkTargetPointsCalculator.cpp
@@ -1,262 +1,262 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // mitk headers
 #include "mitkTargetPointsCalculator.h"
 #include "mitkSurfaceToPointSetFilter.h"
 #include <mitkImageCast.h>
 #include <mitkSurfaceToImageFilter.h>
 
 // itk headers
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 typedef itk::Image<unsigned char, 3> ImageType;
 typedef itk::ImageRegionIterator<ImageType> IteratorType;
 
 mitk::TargetPointsCalculator::TargetPointsCalculator()
 {
   // set default values
   m_InterPointDistance = 20;
   m_ErrorMessage = "";
   m_Method = mitk::TargetPointsCalculator::EvenlyDistributedTargetPoints;
 }
 
 mitk::TargetPointsCalculator::~TargetPointsCalculator()
 {
 }
 
 void mitk::TargetPointsCalculator::SetInput(mitk::Surface::Pointer input)
 {
   m_Input = input;
 }
 
 bool mitk::TargetPointsCalculator::DoCalculate()
 {
   if (m_Input.IsNull())
   {
     m_ErrorMessage = "Error in TargetPointsCalculator: please set input first!";
     return false;
   }
 
   if (m_Method == mitk::TargetPointsCalculator::EvenlyDistributedTargetPoints)
   {
     mitk::Image::Pointer binaryImage = this->CreateBinaryImage();
     this->m_Output = this->CreateTargetPoints(binaryImage);
   }
   else if (m_Method == mitk::TargetPointsCalculator::OneTargetPointInCenterOfGravity)
   {
     this->m_Output = this->CreateTargetPointInCOG(m_Input);
   }
   else
   {
     return false;
   }
 
   return true;
 }
 
 void mitk::TargetPointsCalculator::SetTargetPointCalculationMethod(TargetPointCalculationMethod method)
 {
   m_Method = method;
 }
 
 mitk::PointSet::Pointer mitk::TargetPointsCalculator::GetOutput()
 {
   return m_Output;
 }
 
 std::string mitk::TargetPointsCalculator::GetErrorMessage()
 {
   return m_ErrorMessage;
 }
 
 mitk::Image::Pointer mitk::TargetPointsCalculator::CreateBinaryImage()
 {
   //################################################################################
   //###################### create binary image out of stl ##########################
   //################################################################################
 
   typedef unsigned char PixelType;
 
   // get bounding box of current surface
   const mitk::BoundingBox *boundingBox = this->m_Input->GetGeometry()->GetBoundingBox();
   mitk::BoundingBox::PointType minimum = boundingBox->GetMinimum();
   mitk::BoundingBox::PointType maximum = boundingBox->GetMaximum();
 
   // create white itk image
   ImageType::Pointer image = ImageType::New();
   ImageType::IndexType start;
   start[0] = 0;
   start[1] = 0;
   start[2] = 0;
   ImageType::SizeType imageSize;
   imageSize[0] = maximum[0] - minimum[0] + 20;
   imageSize[1] = maximum[1] - minimum[1] + 20;
   imageSize[2] = maximum[2] - minimum[2] + 20;
   ImageType::RegionType region;
   region.SetSize(imageSize);
   region.SetIndex(start);
   image->SetRegions(region);
   image->Allocate();
 
   // set all pixel values to 1
   PixelType pixel = 1;
   IteratorType iterator(image, image->GetRequestedRegion());
   iterator.GoToBegin();
   while (!iterator.IsAtEnd())
   {
     iterator.Set(pixel);
     ++iterator;
   }
 
   // convert to mitk image
   mitk::Image::Pointer mitkImage;
   mitk::CastToMitkImage(image, mitkImage);
   mitk::Point3D orig;
   orig[0] = minimum[0] - 10;
   orig[1] = minimum[1] - 10;
   orig[2] = minimum[2] - 10;
   mitkImage->SetOrigin(orig);
   mitkImage->UpdateOutputInformation();
 
   mitk::SurfaceToImageFilter::Pointer surfaceToImage = mitk::SurfaceToImageFilter::New();
   surfaceToImage->SetImage(mitkImage);
   surfaceToImage->SetInput(m_Input);
   surfaceToImage->MakeOutputBinaryOn();
   surfaceToImage->Update();
 
   return surfaceToImage->GetOutput();
 }
 
 mitk::PointSet::Pointer mitk::TargetPointsCalculator::CreateTargetPoints(mitk::Image::Pointer binaryImage)
 {
   // determine bounding box:
 
   ImageType::Pointer itkImage = ImageType::New();
   mitk::CastToItkImage(binaryImage, itkImage);
 
   itk::Index<3> begin = {{0, 0, 0}};
-  itk::Index<3> end = {{binaryImage->GetDimension(0), binaryImage->GetDimension(1), binaryImage->GetDimension(2)}};
+  itk::Index<3> end = {{static_cast<signed long>(binaryImage->GetDimension(0)), static_cast<signed long>(binaryImage->GetDimension(1)), static_cast<signed long>(binaryImage->GetDimension(2))}};
 
   mitk::Point3D beginWorld;
   mitk::Point3D endWorld;
 
   itkImage->TransformIndexToPhysicalPoint(begin, beginWorld);
   itkImage->TransformIndexToPhysicalPoint(end, endWorld);
   // determine end of bounding box
 
   // Pointset initialisieren
   mitk::PointSet::Pointer returnValue = mitk::PointSet::New();
   int m = 0; // control value for Pointset-ID
 
   // initialize the distance of the points (in mm)
   int abstand = m_InterPointDistance;
 
   //#########################################################
   //############## calculation of the points####################
   //#########################################################
 
   // build up gate:
   mitk::Point3D p;
   for (int i = RoundUpToGatter(beginWorld.GetElement(0), abstand); i < endWorld.GetElement(0); i = i + abstand)
   {
     for (int j = RoundUpToGatter(beginWorld.GetElement(1), abstand); j < endWorld.GetElement(1); j = j + abstand)
     {
       for (int k = RoundUpToGatter(beginWorld.GetElement(2), abstand); k < endWorld.GetElement(2); k = k + abstand)
       {
         mitk::FillVector3D<mitk::Point3D>(p, i, j, k);
 
         // if it is inside the main structure
         if (this->isInside(itkImage, p))
         {
           returnValue->SetPoint(m, p);
           m++;
         }
       }
     }
   }
 
   return returnValue;
 }
 
 int mitk::TargetPointsCalculator::RoundUpToGatter(int i, int gatter)
 {
   int centimeters = RoundUpToCentimeters(i);
   int mod = centimeters % gatter;
   int returnValue = centimeters + (gatter - mod);
   return returnValue;
 }
 
 int mitk::TargetPointsCalculator::RoundUpToCentimeters(int i)
 {
   int returnValue = (i + 9.999) / 10;
   returnValue = returnValue * 10;
   return returnValue;
 }
 
 bool mitk::TargetPointsCalculator::isInside(ImageType::Pointer currentImageAsitkImage, mitk::Point3D p)
 {
   itk::Index<3> contInd;
 
   if (currentImageAsitkImage->TransformPhysicalPointToIndex(p, contInd))
   {
     unsigned short pixel = currentImageAsitkImage->GetPixel(contInd);
     if (pixel == 1)
     {
       return true;
     }
     else
       return false;
   }
   else
     return false;
 }
 
 void mitk::TargetPointsCalculator::SetInterPointDistance(int d)
 {
   this->m_InterPointDistance = d;
 }
 
 mitk::PointSet::Pointer mitk::TargetPointsCalculator::CreateTargetPointInCOG(mitk::Surface::Pointer surface)
 {
   mitk::PointSet::Pointer returnValue = mitk::PointSet::New();
 
   // convert surface to point set
   mitk::SurfaceToPointSetFilter::Pointer mySurfaceToPointSetFilter = mitk::SurfaceToPointSetFilter::New();
   mySurfaceToPointSetFilter->SetInput(surface);
   mySurfaceToPointSetFilter->Update();
   mitk::PointSet::Pointer ptSet = mySurfaceToPointSetFilter->GetOutput();
 
   // calculate CoG
   mitk::Point3D CoG;
   CoG.Fill(0);
   for (int i = 0; i < ptSet->GetSize(); i++)
   {
     CoG[0] += ptSet->GetPoint(i)[0];
     CoG[1] += ptSet->GetPoint(i)[1];
     CoG[2] += ptSet->GetPoint(i)[2];
   }
   CoG[0] /= ptSet->GetSize();
   CoG[1] /= ptSet->GetSize();
   CoG[2] /= ptSet->GetSize();
 
   // update return value
   returnValue->InsertPoint(0, CoG);
 
   return returnValue;
 }