diff --git a/Modules/PhotoacousticsLib/src/Domain/Volume/mitkPAInSilicoTissueVolume.cpp b/Modules/PhotoacousticsLib/src/Domain/Volume/mitkPAInSilicoTissueVolume.cpp
index c6ab1d8e5f..034e1aa585 100644
--- a/Modules/PhotoacousticsLib/src/Domain/Volume/mitkPAInSilicoTissueVolume.cpp
+++ b/Modules/PhotoacousticsLib/src/Domain/Volume/mitkPAInSilicoTissueVolume.cpp
@@ -1,321 +1,325 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkPAInSilicoTissueVolume.h>
 #include <mitkProperties.h>
 #include <mitkCoreServices.h>
 #include <mitkIPropertyPersistence.h>
 #include <itkImage.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <chrono>
 
 mitk::pa::InSilicoTissueVolume::InSilicoTissueVolume(TissueGeneratorParameters::Pointer parameters)
 {
   {
     unsigned int xDim = parameters->GetXDim();
     unsigned int yDim = parameters->GetYDim();
     unsigned int zDim = parameters->GetZDim();
     m_TDim = 4;
     unsigned int size = xDim * yDim * zDim;
     double* absorptionArray = new double[size];
     double* scatteringArray = new double[size];
     double* anisotropyArray = new double[size];
     double* segmentationArray = new double[size];
 
     for (unsigned int index = 0; index < size; index++)
     {
       absorptionArray[index] = parameters->GetBackgroundAbsorption();
       scatteringArray[index] = parameters->GetBackgroundScattering();
       anisotropyArray[index] = parameters->GetBackgroundAnisotropy();
       segmentationArray[index] = SegmentationType::BACKGROUND;
     }
 
     m_AbsorptionVolume = Volume::New(absorptionArray, xDim, yDim, zDim);
     m_ScatteringVolume = Volume::New(scatteringArray, xDim, yDim, zDim);
     m_AnisotropyVolume = Volume::New(anisotropyArray, xDim, yDim, zDim);
     m_SegmentationVolume = Volume::New(segmentationArray, xDim, yDim, zDim);
   }
 
   m_TissueParameters = parameters;
   m_PropertyList = mitk::PropertyList::New();
   UpdatePropertyList();
 }
 
 void mitk::pa::InSilicoTissueVolume::UpdatePropertyList()
 {
   //Set properties
   AddIntProperty("mcflag", m_TissueParameters->GetMCflag());
   AddIntProperty("launchflag", m_TissueParameters->GetMCLaunchflag());
   AddIntProperty("boundaryflag", m_TissueParameters->GetMCBoundaryflag());
   AddDoubleProperty("launchPointX", m_TissueParameters->GetMCLaunchPointX());
   AddDoubleProperty("launchPointY", m_TissueParameters->GetMCLaunchPointY());
   AddDoubleProperty("launchPointZ", m_TissueParameters->GetMCLaunchPointZ());
   AddDoubleProperty("focusPointX", m_TissueParameters->GetMCFocusPointX());
   AddDoubleProperty("focusPointY", m_TissueParameters->GetMCFocusPointY());
   AddDoubleProperty("focusPointZ", m_TissueParameters->GetMCFocusPointZ());
   AddDoubleProperty("trajectoryVectorX", m_TissueParameters->GetMCTrajectoryVectorX());
   AddDoubleProperty("trajectoryVectorY", m_TissueParameters->GetMCTrajectoryVectorY());
   AddDoubleProperty("trajectoryVectorZ", m_TissueParameters->GetMCTrajectoryVectorZ());
   AddDoubleProperty("radius", m_TissueParameters->GetMCRadius());
   AddDoubleProperty("waist", m_TissueParameters->GetMCWaist());
   if (m_TissueParameters->GetDoVolumeSmoothing())
     AddDoubleProperty("sigma", m_TissueParameters->GetVolumeSmoothingSigma());
   else
     AddDoubleProperty("sigma", 0);
   AddDoubleProperty("standardTissueAbsorption", m_TissueParameters->GetBackgroundAbsorption());
   AddDoubleProperty("standardTissueScattering", m_TissueParameters->GetBackgroundScattering());
   AddDoubleProperty("standardTissueAnisotropy", m_TissueParameters->GetBackgroundAnisotropy());
   AddDoubleProperty("airThickness", m_TissueParameters->GetAirThicknessInMillimeters());
   AddDoubleProperty("skinThickness", m_TissueParameters->GetSkinThicknessInMillimeters());
 }
 
 mitk::pa::InSilicoTissueVolume::InSilicoTissueVolume(
   Volume::Pointer absorptionVolume,
   Volume::Pointer scatteringVolume,
   Volume::Pointer anisotropyVolume,
   Volume::Pointer segmentationVolume,
   TissueGeneratorParameters::Pointer tissueParameters,
   mitk::PropertyList::Pointer propertyList)
 {
   m_AbsorptionVolume = absorptionVolume;
   m_ScatteringVolume = scatteringVolume;
   m_AnisotropyVolume = anisotropyVolume;
   m_SegmentationVolume = segmentationVolume;
   m_TissueParameters = tissueParameters;
   m_PropertyList = propertyList;
   if (m_SegmentationVolume.IsNotNull())
     m_TDim = 4;
   else
     m_TDim = 3;
 }
 
 void mitk::pa::InSilicoTissueVolume::AddDoubleProperty(std::string label, double value)
 {
   m_PropertyList->SetDoubleProperty(label.c_str(), value);
   mitk::CoreServices::GetPropertyPersistence()->AddInfo(mitk::PropertyPersistenceInfo::New(label));
 }
 
 void mitk::pa::InSilicoTissueVolume::AddIntProperty(std::string label, int value)
 {
   m_PropertyList->SetIntProperty(label.c_str(), value);
   mitk::CoreServices::GetPropertyPersistence()->AddInfo(mitk::PropertyPersistenceInfo::New(label));
 }
 
 mitk::Image::Pointer mitk::pa::InSilicoTissueVolume::ConvertToMitkImage()
 {
   mitk::Image::Pointer resultImage = mitk::Image::New();
   mitk::PixelType TPixel = mitk::MakeScalarPixelType<double>();
   unsigned int* dimensionsOfImage = new unsigned int[4];
 
   // Copy dimensions
   dimensionsOfImage[0] = m_TissueParameters->GetYDim();
   dimensionsOfImage[1] = m_TissueParameters->GetXDim();
   dimensionsOfImage[2] = m_TissueParameters->GetZDim();
   dimensionsOfImage[3] = m_TDim;
 
   MITK_INFO << "Initializing image...";
   resultImage->Initialize(TPixel, 4, dimensionsOfImage, 1);
   MITK_INFO << "Initializing image...[Done]";
 
   mitk::Vector3D spacing;
   spacing.Fill(m_TissueParameters->GetVoxelSpacingInCentimeters());
   resultImage->SetSpacing(spacing);
 
   MITK_INFO << "Set Import Volumes...";
   //Copy memory, deal with cleaning up memory yourself!
   resultImage->SetImportVolume(m_AbsorptionVolume->GetData(), 0, 0, mitk::Image::CopyMemory);
   resultImage->SetImportVolume(m_ScatteringVolume->GetData(), 1, 0, mitk::Image::CopyMemory);
   resultImage->SetImportVolume(m_AnisotropyVolume->GetData(), 2, 0, mitk::Image::CopyMemory);
   resultImage->SetImportVolume(m_SegmentationVolume->GetData(), 3, 0, mitk::Image::CopyMemory);
   MITK_INFO << "Set Import Volumes...[Done]";
 
   resultImage->SetPropertyList(m_PropertyList);
 
   return resultImage;
 }
 
 mitk::pa::InSilicoTissueVolume::Pointer mitk::pa::InSilicoTissueVolume::New(
   Volume::Pointer absorptionVolume,
   Volume::Pointer scatteringVolume,
   Volume::Pointer anisotropyVolume,
   Volume::Pointer segmentationVolume,
   TissueGeneratorParameters::Pointer tissueParameters,
   mitk::PropertyList::Pointer propertyList)
 {
   InSilicoTissueVolume::Pointer smartPtr = new InSilicoTissueVolume(
     absorptionVolume, scatteringVolume, anisotropyVolume, segmentationVolume,
     tissueParameters, propertyList);
   smartPtr->UnRegister();
   return smartPtr;
 }
 
 mitk::pa::InSilicoTissueVolume::~InSilicoTissueVolume()
 {
   m_AbsorptionVolume = nullptr;
   m_ScatteringVolume = nullptr;
   m_AnisotropyVolume = nullptr;
   m_SegmentationVolume = nullptr;
   m_TissueParameters = nullptr;
   m_PropertyList = nullptr;
 }
 
 void mitk::pa::InSilicoTissueVolume::SetVolumeValues(int x, int y, int z, double absorption, double scattering, double anisotropy, SegmentationType segmentType)
 {
   if (IsInsideVolume(x, y, z))
   {
     m_AbsorptionVolume->SetData(absorption, x, y, z);
     m_ScatteringVolume->SetData(scattering, x, y, z);
     m_AnisotropyVolume->SetData(anisotropy, x, y, z);
     m_SegmentationVolume->SetData(segmentType, x, y, z);
   }
 }
 
 bool mitk::pa::InSilicoTissueVolume::IsInsideVolume(int x, int y, int z)
 {
   return x >= 0 && x < m_TissueParameters->GetXDim() &&
     y >= 0 && y < m_TissueParameters->GetYDim() &&
     z >= 0 && z < m_TissueParameters->GetZDim();
 }
 
 mitk::pa::Volume::Pointer mitk::pa::InSilicoTissueVolume::GetAbsorptionVolume()
 {
   return m_AbsorptionVolume;
 }
 
 mitk::pa::Volume::Pointer mitk::pa::InSilicoTissueVolume::GetSegmentationVolume()
 {
   return m_SegmentationVolume;
 }
 
 void mitk::pa::InSilicoTissueVolume::FinalizeVolume()
 {
   AddSkinAndAirLayers();
 
   // If specified, randomize all tissue parameters
   if (m_TissueParameters->GetRandomizePhysicalProperties())
     RandomizeTissueCoefficients(m_TissueParameters->GetUseRngSeed(),
       m_TissueParameters->GetRngSeed(),
       m_TissueParameters->GetRandomizePhysicalPropertiesPercentage());
 }
 
 void mitk::pa::InSilicoTissueVolume::AddSkinAndAirLayers()
 {
   //Calculate the index location according to thickness in cm
   double airvoxel = (m_TissueParameters->GetAirThicknessInMillimeters() / m_TissueParameters->GetVoxelSpacingInCentimeters()) / 10;
   double skinvoxel = airvoxel + (m_TissueParameters->GetSkinThicknessInMillimeters() / m_TissueParameters->GetVoxelSpacingInCentimeters()) / 10;
 
   for (int y = 0; y < m_TissueParameters->GetYDim(); y++)
   {
     for (int x = 0; x < m_TissueParameters->GetXDim(); x++)
     {
       // Add air from index 0 to airvoxel
       if (m_TissueParameters->GetAirThicknessInMillimeters() > mitk::eps)
       {
         FillZLayer(x, y, 0, airvoxel,
           m_TissueParameters->GetAirAbsorption(),
           m_TissueParameters->GetAirScattering(),
           m_TissueParameters->GetAirAnisotropy(),
           SegmentationType::AIR);
       }
 
       //Add skin from index airvoxel to skinvoxel
       if (m_TissueParameters->GetSkinThicknessInMillimeters() > mitk::eps)
       {
         FillZLayer(x, y, airvoxel, skinvoxel,
           m_TissueParameters->GetSkinAbsorption(),
           m_TissueParameters->GetSkinScattering(),
           m_TissueParameters->GetSkinAnisotropy(),
           SegmentationType::SKIN);
       }
     }
   }
 }
 
 void mitk::pa::InSilicoTissueVolume::FillZLayer(int x, int y, double startIdx, double endIdx,
   double absorption, double scattering, double anisotropy,
   SegmentationType segmentationType)
 {
   for (int z = startIdx; z < endIdx; z++)
+  {
     if (IsInsideVolume(x, y, z))
+    {
       if (endIdx - z < 1)
       {
         //Simulate partial volume effects
         m_AbsorptionVolume->SetData((1 - (endIdx - z)) *
           m_AbsorptionVolume->GetData(x, y, z) + (endIdx - z) * absorption, x, y, z);
         m_ScatteringVolume->SetData((1 - (endIdx - z)) *
           m_ScatteringVolume->GetData(x, y, z) + (endIdx - z) * scattering, x, y, z);
         m_AnisotropyVolume->SetData((1 - (endIdx - z)) *
           m_AnisotropyVolume->GetData(x, y, z) + (endIdx - z) * anisotropy, x, y, z);
         if (endIdx - z > 0.5)
         {
           //Only put the segmentation label if more than half of the partial volume is the wanted tissue type
           m_SegmentationVolume->SetData(segmentationType, x, y, z);
         }
       }
       else
       {
         m_AbsorptionVolume->SetData(absorption, x, y, z);
         m_ScatteringVolume->SetData(scattering, x, y, z);
         m_AnisotropyVolume->SetData(anisotropy, x, y, z);
         m_SegmentationVolume->SetData(segmentationType, x, y, z);
       }
+    }
+  }
 }
 
 void mitk::pa::InSilicoTissueVolume::RandomizeTissueCoefficients(long rngSeed, bool useRngSeed, double percentage)
 {
   std::mt19937 rng;
   std::random_device randomDevice;
   if (useRngSeed)
   {
     rng.seed(rngSeed);
   }
   else
   {
     if (randomDevice.entropy() > 0.1)
     {
       rng.seed(randomDevice());
     }
     else
     {
       rng.seed(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
     }
   }
   std::normal_distribution<> percentageDistribution(1, percentage / 100);
 
   for (int y = 0; y < m_TissueParameters->GetYDim(); y++)
   {
     for (int x = 0; x < m_TissueParameters->GetXDim(); x++)
     {
       for (int z = 0; z < m_TissueParameters->GetZDim(); z++)
       {
         m_AbsorptionVolume->SetData(m_AbsorptionVolume->GetData(x, y, z) * percentageDistribution(rng), x, y, z);
         m_ScatteringVolume->SetData(m_ScatteringVolume->GetData(x, y, z) * percentageDistribution(rng), x, y, z);
       }
     }
   }
 }
 
 mitk::pa::Volume::Pointer mitk::pa::InSilicoTissueVolume::GetScatteringVolume()
 {
   return m_ScatteringVolume;
 }
 
 mitk::pa::Volume::Pointer mitk::pa::InSilicoTissueVolume::GetAnisotropyVolume()
 {
   return m_AnisotropyVolume;
 }
diff --git a/Modules/PhotoacousticsLib/src/IO/mitkPAIOUtil.cpp b/Modules/PhotoacousticsLib/src/IO/mitkPAIOUtil.cpp
index 99e2260545..6f0b374dfa 100644
--- a/Modules/PhotoacousticsLib/src/IO/mitkPAIOUtil.cpp
+++ b/Modules/PhotoacousticsLib/src/IO/mitkPAIOUtil.cpp
@@ -1,253 +1,253 @@
 #include "mitkPAIOUtil.h"
 
 #include "mitkIOUtil.h"
 #include "mitkImageReadAccessor.h"
 
 #include <string>
 #include <sstream>
 #include <vector>
 
 #include "mitkPAComposedVolume.h"
 #include "mitkPASlicedVolumeGenerator.h"
 #include "mitkPANoiseGenerator.h"
 #include "mitkPAVolumeManipulator.h"
 #include <mitkProperties.h>
 #include <itkDirectory.h>
-#include <itksys\SystemTools.hxx>
+#include <itksys/SystemTools.hxx>
 
 static std::vector<int> splitString(const std::string &s, const char* delim) {
   std::vector<int> elems;
   std::stringstream ss(s);
   std::string item;
   while (std::getline(ss, item, *delim))
   {
     int numb;
     std::stringstream(item) >> numb;
     elems.push_back(numb);
   }
   return elems;
 }
 
 bool mitk::pa::IOUtil::DoesFileHaveEnding(std::string const &fullString, std::string const &ending) {
   if (fullString.length() == 0 || ending.length() == 0 || fullString.length() < ending.length())
     return false;
 
   return (0 == fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
 }
 
 mitk::pa::IOUtil::IOUtil() {}
 
 mitk::pa::IOUtil::~IOUtil() {}
 
 mitk::pa::Volume::Pointer mitk::pa::IOUtil::LoadNrrd(std::string filename, double blur)
 {
   if (filename.empty() || filename == "")
     return nullptr;
 
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(filename);
 
   if (inputImage.IsNull())
     return nullptr;
 
   int xDim = inputImage->GetDimensions()[1];
   int yDim = inputImage->GetDimensions()[0];
   int zDim = inputImage->GetDimensions()[2];
 
   mitk::ImageReadAccessor readAccess(inputImage, inputImage->GetVolumeData(0));
 
   double* dataArray = new double[xDim*yDim*zDim];
   const double* srcData = (const double*)readAccess.GetData();
   memcpy(dataArray, srcData, xDim*yDim*zDim * sizeof(double));
 
   auto returnImage = mitk::pa::Volume::New(dataArray, xDim, yDim, zDim);
 
   mitk::pa::VolumeManipulator::GaussianBlur3D(returnImage, blur);
 
   return returnImage;
 }
 
 std::map<mitk::pa::IOUtil::Position, mitk::pa::Volume::Pointer>
 mitk::pa::IOUtil::LoadFluenceContributionMaps(std::string foldername, double blur, int* progress, bool doLog10)
 {
   std::map<IOUtil::Position, Volume::Pointer> resultMap;
 
   itk::Directory::Pointer directoryHandler = itk::Directory::New();
   directoryHandler->Load(foldername.c_str());
   for (unsigned int fileIndex = 0, numFiles = directoryHandler->GetNumberOfFiles(); fileIndex < numFiles; ++fileIndex)
   {
     std::string filename = std::string(directoryHandler->GetFile(fileIndex));
     if (itksys::SystemTools::FileIsDirectory(filename))
       continue;
 
     if (!DoesFileHaveEnding(filename, ".nrrd"))
       continue;
 
     size_t s = filename.find("_p");
     size_t e = filename.find("Fluence", s);
     std::string sub = filename.substr(s + 2, e - s - 2);
     std::vector<int> coords = splitString(sub, ",");
 
     if (coords.size() != 3)
     {
       MITK_ERROR << "Some of the data to read was corrupted or did not match the " <<
         "naming pattern *_pN,N,NFluence*.nrrd";
       mitkThrow() << "Some of the data to read was corrupted or did not match the" <<
         " naming pattern *_pN,N,NFluence*.nrrd";
     }
     else
     {
       MITK_DEBUG << "Extracted coords: " << coords[0] << "|" << coords[1] << "|" << coords[2] << " from string " << sub;
       Volume::Pointer nrrdFile = LoadNrrd(foldername + filename, blur);
       if (doLog10)
         VolumeManipulator::Log10Image(nrrdFile);
       resultMap[Position{ coords[0], coords[2] }] = nrrdFile;
       *progress = *progress + 1;
     }
   }
 
   return resultMap;
 }
 
 int mitk::pa::IOUtil::GetNumberOfNrrdFilesInDirectory(std::string directory)
 {
   return GetListOfAllNrrdFilesInDirectory(directory).size();
 }
 
 std::vector<std::string> mitk::pa::IOUtil::GetListOfAllNrrdFilesInDirectory(std::string directory, bool keepFileFormat)
 {
   std::vector<std::string> filenames;
   itk::Directory::Pointer directoryHandler = itk::Directory::New();
   directoryHandler->Load(directory.c_str());
   for (unsigned int fileIndex = 0, numFiles = directoryHandler->GetNumberOfFiles(); fileIndex < numFiles; ++fileIndex)
   {
     std::string filename = std::string(directoryHandler->GetFile(fileIndex));
     if (itksys::SystemTools::FileIsDirectory(filename))
       continue;
 
     if (!DoesFileHaveEnding(filename, ".nrrd"))
       continue;
 
     if (keepFileFormat)
     {
       filenames.push_back(filename);
     }
     else
     {
       filenames.push_back(filename.substr(0, filename.size() - 5));
     }
   }
 
   return filenames;
 }
 
 std::vector<std::string> mitk::pa::IOUtil::GetAllChildfoldersFromFolder(std::string folderPath)
 {
   std::vector<std::string> returnVector;
 
   itksys::Directory directoryHandler;
   directoryHandler.Load(folderPath.c_str());
   for (unsigned int fileIndex = 2, numFiles = directoryHandler.GetNumberOfFiles(); fileIndex < numFiles; ++fileIndex)
   {
     std::string filename = folderPath + "/" + std::string(directoryHandler.GetFile(fileIndex));
     if (itksys::SystemTools::FileIsDirectory(filename))
     {
       returnVector.push_back(filename);
       continue;
     }
 
     //If there is a nrrd file in the directory we assume that a bottom level directory was chosen.
     if (DoesFileHaveEnding(filename, ".nrrd"))
     {
       returnVector.clear();
       returnVector.push_back(folderPath);
       return returnVector;
     }
   }
 
   return returnVector;
 }
 
 mitk::pa::InSilicoTissueVolume::Pointer mitk::pa::IOUtil::LoadInSilicoTissueVolumeFromNrrdFile(std::string nrrdFile)
 {
   MITK_INFO << "Initializing ComposedVolume by nrrd...";
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(nrrdFile);
 
   auto tissueParameters = TissueGeneratorParameters::New();
 
   unsigned int xDim = inputImage->GetDimensions()[1];
   unsigned int yDim = inputImage->GetDimensions()[0];
   unsigned int zDim = inputImage->GetDimensions()[2];
   tissueParameters->SetXDim(xDim);
   tissueParameters->SetYDim(yDim);
   tissueParameters->SetZDim(zDim);
 
   double xSpacing = inputImage->GetGeometry(0)->GetSpacing()[1];
   double ySpacing = inputImage->GetGeometry(0)->GetSpacing()[0];
   double zSpacing = inputImage->GetGeometry(0)->GetSpacing()[2];
 
   if ((xSpacing - ySpacing) > mitk::eps || (xSpacing - zSpacing) > mitk::eps || (ySpacing - zSpacing) > mitk::eps)
   {
     throw mitk::Exception("Cannot handle unequal spacing.");
   }
 
   tissueParameters->SetVoxelSpacingInCentimeters(xSpacing);
 
   mitk::PropertyList::Pointer propertyList = inputImage->GetPropertyList();
 
   mitk::ImageReadAccessor readAccess0(inputImage, inputImage->GetVolumeData(0));
   double* m_AbsorptionArray = new double[xDim*yDim*zDim];
   memcpy(m_AbsorptionArray, readAccess0.GetData(), xDim*yDim*zDim * sizeof(double));
   auto absorptionVolume = Volume::New(m_AbsorptionArray, xDim, yDim, zDim);
 
   mitk::ImageReadAccessor readAccess1(inputImage, inputImage->GetVolumeData(1));
   double*  m_ScatteringArray = new double[xDim*yDim*zDim];
   memcpy(m_ScatteringArray, readAccess1.GetData(), xDim*yDim*zDim * sizeof(double));
   auto scatteringVolume = Volume::New(m_ScatteringArray, xDim, yDim, zDim);
 
   mitk::ImageReadAccessor readAccess2(inputImage, inputImage->GetVolumeData(2));
   double*  m_AnisotropyArray = new double[xDim*yDim*zDim];
   memcpy(m_AnisotropyArray, readAccess2.GetData(), xDim*yDim*zDim * sizeof(double));
   auto anisotropyVolume = Volume::New(m_AnisotropyArray, xDim, yDim, zDim);
 
   Volume::Pointer segmentationVolume;
 
   if (inputImage->GetDimension() == 4)
   {
     mitk::ImageReadAccessor readAccess3(inputImage, inputImage->GetVolumeData(3));
     double*  m_SegmentationArray = new double[xDim*yDim*zDim];
     memcpy(m_SegmentationArray, readAccess3.GetData(), xDim*yDim*zDim * sizeof(double));
     segmentationVolume = Volume::New(m_SegmentationArray, xDim, yDim, zDim);
   }
 
   return mitk::pa::InSilicoTissueVolume::New(absorptionVolume, scatteringVolume,
     anisotropyVolume, segmentationVolume, tissueParameters, propertyList);
 }
 
 mitk::pa::FluenceYOffsetPair::Pointer mitk::pa::IOUtil::LoadFluenceSimulation(std::string fluenceSimulation)
 {
   MITK_INFO << "Adding slice...";
 
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(fluenceSimulation);
   mitk::ImageReadAccessor readAccess0(inputImage, inputImage->GetVolumeData(0));
 
   unsigned int xDim = inputImage->GetDimensions()[1];
   unsigned int yDim = inputImage->GetDimensions()[0];
   unsigned int zDim = inputImage->GetDimensions()[2];
   int size = xDim*yDim*zDim;
   double* fluenceArray = new double[size];
   memcpy(fluenceArray, readAccess0.GetData(), size * sizeof(double));
 
   auto yOffsetProperty = inputImage->GetProperty("y-offset");
 
   if (yOffsetProperty.IsNull())
     mitkThrow() << "No \"y-offset\" property found in fluence file!";
 
   std::string yOff = yOffsetProperty->GetValueAsString();
   MITK_INFO << "Reading y Offset: " << yOff;
 #ifdef __linux__
   std::replace(yOff.begin(), yOff.end(), '.', ',');
 #endif // __linux__
   double yOffset = std::stod(yOff);
   MITK_INFO << "Converted offset " << yOffset;
   return mitk::pa::FluenceYOffsetPair::New(mitk::pa::Volume::New(fluenceArray, xDim, yDim, zDim), yOffset);
 }