diff --git a/Modules/PhotoacousticsAlgorithms/MitkPABeamformingTool/PABeamformingTool.cpp b/Modules/PhotoacousticsAlgorithms/MitkPABeamformingTool/PABeamformingTool.cpp
index 2b2adf2b00..81f0520417 100644
--- a/Modules/PhotoacousticsAlgorithms/MitkPABeamformingTool/PABeamformingTool.cpp
+++ b/Modules/PhotoacousticsAlgorithms/MitkPABeamformingTool/PABeamformingTool.cpp
@@ -1,228 +1,232 @@
 /*===================================================================
 
 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 <mitkCommon.h>
 #include <chrono>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <mitkException.h>
 
 #include <mitkPhotoacousticFilterService.h>
-#include <mitkPhotoacousticBeamformingSettings.h>
+#include <mitkBeamformingSettings.h>
+#include <mitkCastToFloatImageFilter.h>
 
 #include <itksys/SystemTools.hxx>
 
 struct InputParameters
 {
   mitk::Image::Pointer inputImage;
   std::string outputFilename;
   bool verbose;
-  int speedOfSound;
-  int cutoff;
+  float speedOfSound;
+  unsigned int cutoff;
   float angle;
-  int samples;
+  unsigned int samples;
   mitk::BeamformingSettings::BeamformingAlgorithm algorithm;
 };
 
 InputParameters parseInput(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setCategory("MITK-Photoacoustics");
   parser.setTitle("Mitk Photoacoustics Beamforming Tool");
   parser.setDescription("Reads a nrrd file as an input and applies a beamforming method as set with the parameters.");
   parser.setContributor("Computer Assisted Medical Interventions, DKFZ");
 
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("Required parameters");
   parser.addArgument(
     "inputImage", "i", mitkCommandLineParser::InputImage,
     "Input image (mitk::Image)", "input image (.nrrd file)",
     us::Any(), false);
   parser.addArgument(
     "output", "o", mitkCommandLineParser::OutputFile,
     "Output filename", "output image (.nrrd file)",
     us::Any(), false);
   parser.endGroup();
 
   parser.beginGroup("Optional parameters");
   parser.addArgument(
     "verbose", "v", mitkCommandLineParser::Bool,
     "Verbose Output", "Whether to produce verbose, or rather debug output. (default: false)");
   parser.addArgument(
-    "speed-of-sound", "sos", mitkCommandLineParser::Int,
+    "speed-of-sound", "sos", mitkCommandLineParser::Float,
     "Speed of Sound [m/s]", "The average speed of sound as assumed for the reconstruction in [m/s]. (default: 1500)");
   parser.addArgument(
     "cutoff", "co", mitkCommandLineParser::Int,
     "cutoff margin on the top of the image [pixels]", "The number of pixels to be ignored for this filter in [pixels] (default: 0).");
   parser.addArgument(
     "angle", "a", mitkCommandLineParser::Float,
     "field of view of the transducer elements [degrees]", "The field of view of each individual transducer element [degrees] (default: 27).");
   parser.addArgument(
     "samples", "s", mitkCommandLineParser::Int,
     "samples per reconstruction line [pixels]", "The pixels along the y axis in the beamformed image [pixels] (default: 2048).");
   parser.addArgument(
     "algorithm", "alg", mitkCommandLineParser::String,
     "one of [\"DAS\", \"DMAS\", \"sDMAS\"]", "The beamforming algorithm to be used for reconstruction (default: DAS).");
   parser.endGroup();
 
   InputParameters input;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size() == 0)
     exit(-1);
 
   if (parsedArgs.count("verbose"))
   {
     input.verbose = true;
   }
   else
   {
     input.verbose = false;
   }
   MITK_INFO(input.verbose) << "### VERBOSE OUTPUT ENABLED ###";
 
   if (parsedArgs.count("inputImage"))
   {
     MITK_INFO(input.verbose) << "Reading input image...";
     input.inputImage = mitk::IOUtil::Load<mitk::Image>(us::any_cast<std::string>(parsedArgs["inputImage"]));
     MITK_INFO(input.verbose) << "Reading input image...[Done]";
   }
   else
   {
     mitkThrow() << "No input image given.";
   }
 
   if (parsedArgs.count("output"))
   {
     input.outputFilename = us::any_cast<std::string>(parsedArgs["output"]);
   }
   else
   {
     mitkThrow() << "No output image path given..";
   }
 
   if (parsedArgs.count("speed-of-sound"))
   {
     input.speedOfSound = us::any_cast<int>(parsedArgs["speed-of-sound"]);
   }
   else
   {
     input.speedOfSound = 1500;
   }
 
   if (parsedArgs.count("cutoff"))
   {
     input.cutoff = us::any_cast<int>(parsedArgs["cutoff"]);
   }
   else
   {
     input.cutoff = 0;
   }
 
   if (parsedArgs.count("angle"))
   {
     input.angle = us::any_cast<float>(parsedArgs["angle"]);
   }
   else
   {
     input.angle = 27;
   }
 
   if (parsedArgs.count("samples"))
   {
     input.samples = us::any_cast<int>(parsedArgs["samples"]);
   }
   else
   {
     input.samples = 2048;
   }
 
   if (parsedArgs.count("algorithm"))
   {
     std::string algorithm = us::any_cast<std::string>(parsedArgs["algorithm"]);
     MITK_INFO(input.verbose) << "Parsing algorithm: " << algorithm;
     if (algorithm == "DAS")
       input.algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DAS;
     else if (algorithm == "DMAS")
       input.algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DMAS;
     else if (algorithm == "sDMAS")
       input.algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::sDMAS;
     else
     {
       MITK_INFO(input.verbose) << "Not a valid beamforming algorithm: " << algorithm << " Reverting to DAS";
       input.algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DAS;
     }
 
     MITK_INFO(input.verbose) << "Sucessfully set algorithm: " << algorithm;
   }
   else
   {
     input.algorithm = mitk::BeamformingSettings::BeamformingAlgorithm::DAS;
     MITK_INFO(input.verbose) << "No matching algorithm found. Using DAS.";
   }
 
   return input;
 }
 
 mitk::BeamformingSettings::Pointer ParseSettings(InputParameters &input)
 {
-  mitk::BeamformingSettings::Pointer outputSettings = mitk::BeamformingSettings::New();
-
-  outputSettings->SetAlgorithm(input.algorithm);
-  outputSettings->SetApod(mitk::BeamformingSettings::Apodization::Box);
-  outputSettings->SetSpeedOfSound(input.speedOfSound);
-  outputSettings->SetTimeSpacing(input.inputImage->GetGeometry()->GetSpacing()[1] / 1000000);
-  outputSettings->SetRecordTime(input.inputImage->GetDimension(1)*input.inputImage->GetGeometry()->GetSpacing()[1] / 1000000); // [s]
-  outputSettings->SetUseGPU(false);
-  outputSettings->SetUpperCutoff(input.cutoff);
-  outputSettings->SetDelayCalculationMethod(mitk::BeamformingSettings::DelayCalc::Spherical);
-  outputSettings->SetAngle(input.angle);
-  outputSettings->SetPitch(input.inputImage->GetGeometry()->GetSpacing()[0] / 1000);
-  outputSettings->SetTransducerElements(input.inputImage->GetDimension(0));
-  outputSettings->SetReconstructionLines(input.inputImage->GetDimension(0));
-  outputSettings->SetSamplesPerLine(input.samples);
-  outputSettings->SetIsPhotoacousticImage(true);
-  outputSettings->SetPartial(false);
-  outputSettings->SetApodizationArraySize(input.inputImage->GetDimension(0));
-  outputSettings->SetUseBP(false);
+  mitk::BeamformingSettings::Pointer outputSettings = mitk::BeamformingSettings::New(
+    (float)(input.inputImage->GetGeometry()->GetSpacing()[0] / 1000),
+    (float)(input.speedOfSound),
+    (float)(input.inputImage->GetGeometry()->GetSpacing()[1] / 1000000),
+    input.angle,
+    true,
+    input.inputImage->GetDimension(0),
+    input.cutoff,
+    false,
+    (unsigned int*) nullptr,
+    input.inputImage->GetDimensions(),
+    false,
+    mitk::BeamformingSettings::DelayCalc::Spherical,
+    mitk::BeamformingSettings::Apodization::Box,
+    input.inputImage->GetDimension(0),
+    input.algorithm,
+    false,
+    0.0f,
+    0.0f);
 
   return outputSettings;
 }
 
 int main(int argc, char * argv[])
 {
   auto input = parseInput(argc, argv);
 
   MITK_INFO(input.verbose) << "Beamforming input image...";
 
   mitk::PhotoacousticFilterService::Pointer m_BeamformingService = mitk::PhotoacousticFilterService::New();
 
   mitk::BeamformingSettings::Pointer settings = ParseSettings(input);
 
-  std::string message = "Test";
+  mitk::CastToFloatImageFilter::Pointer castFilter = mitk::CastToFloatImageFilter::New();
+  castFilter->SetInput(input.inputImage);
+  castFilter->Update();
+  auto floatImage = castFilter->GetOutput();
 
-  auto output = m_BeamformingService->ApplyBeamforming(input.inputImage, settings, message);
+  auto output = m_BeamformingService->ApplyBeamforming(floatImage, settings);
   MITK_INFO(input.verbose) << "Applying BModeFilter to image...";
   //output = m_BeamformingService->ApplyBmodeFilter(output, mitk::PhotoacousticFilterService::Abs, false, false, 0.3);
   MITK_INFO(input.verbose) << "Applying BModeFilter to image...[Done]";
 
   MITK_INFO(input.verbose) << "Saving image...";
   mitk::IOUtil::Save(output, input.outputFilename);
   MITK_INFO(input.verbose) << "Saving image...[Done]";
 
   MITK_INFO(input.verbose) << "Beamforming input image...[Done]";
 }
diff --git a/Modules/PhotoacousticsAlgorithms/files.cmake b/Modules/PhotoacousticsAlgorithms/files.cmake
index 0aeeaf0b4b..80c89f8144 100644
--- a/Modules/PhotoacousticsAlgorithms/files.cmake
+++ b/Modules/PhotoacousticsAlgorithms/files.cmake
@@ -1,29 +1,30 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   source/filters/mitkBeamformingFilter.cpp
+  source/filters/mitkBeamformingSettings.cpp
   source/filters/mitkImageSliceSelectionFilter.cpp
   source/filters/mitkCastToFloatImageFilter.cpp
   source/filters/mitkCropImageFilter.cpp
   source/OpenCLFilter/mitkPhotoacousticBModeFilter.cpp
   source/utils/mitkPhotoacousticFilterService.cpp
   source/utils/mitkBeamformingUtils.cpp
 )
 
 IF(MITK_USE_OpenCL)
 list(APPEND CPP_FILES
     source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
     source/OpenCLFilter/mitkPhotoacousticOCLUsedLinesCalculation.cpp
     source/OpenCLFilter/mitkPhotoacousticOCLDelayCalculation.cpp
 )
 ENDIF(MITK_USE_OpenCL)
 
 set(RESOURCE_FILES
   BModeAbs.cl
   BModeAbsLog.cl
   UsedLinesCalculation.cl
   DelayCalculation.cl
   DMAS.cl
   DAS.cl
   sDMAS.cl
 )
diff --git a/Modules/PhotoacousticsAlgorithms/include/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h b/Modules/PhotoacousticsAlgorithms/include/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h
index 25cbeb49e3..ff7d62b1be 100644
--- a/Modules/PhotoacousticsAlgorithms/include/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h
+++ b/Modules/PhotoacousticsAlgorithms/include/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h
@@ -1,145 +1,145 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef _MITKPHOTOACOUSTICSOCLBEAMFORMER_H_
 #define _MITKPHOTOACOUSTICSOCLBEAMFORMER_H_
 
 #include <itkObject.h>
 
 #if defined(PHOTOACOUSTICS_USE_GPU) || DOXYGEN
 
 #include "mitkOclDataSetToDataSetFilter.h"
 
 #include "mitkPhotoacousticOCLDelayCalculation.h"
 #include "mitkPhotoacousticOCLUsedLinesCalculation.h"
 #include "mitkBeamformingSettings.h"
 
 #include <chrono>
 
 namespace mitk
 {
   /*!
   * \brief Class implementing a mitk::OclDataSetToDataSetFilter for beamforming on GPU
   *
   *  The class must be given a configuration class instance of mitk::BeamformingSettings for beamforming parameters through mitk::PhotoacousticOCLBeamformingFilter::SetConfig(BeamformingSettings settings)
   *  Additional configuration of the apodisation function is needed.
   */
 
   class PhotoacousticOCLBeamformingFilter : public OclDataSetToDataSetFilter, public itk::Object
   {
   public:
     mitkClassMacroItkParent(PhotoacousticOCLBeamformingFilter, itk::Object);
     mitkNewMacro1Param(Self, BeamformingSettings::Pointer);
 
     /**
     * @brief SetInput Set the input data through an image. Arbitrary images are supported
     */
     void SetInput(Image::Pointer image);
     /**
     *  brief SetInput Manually set the input data while providing 3 dimensions and memory size of the input data (Bytes per element).
     */
     void SetInput(void* data, unsigned int* dimensions, unsigned int BpE);
     /**
     * @brief GetOutput Get a pointer to the processed data. The standard datatype is float.
     */
     void* GetOutput();
 
     /**
     * @brief GetOutputAsImage Returns an mitk::Image constructed from the processed data
     */
     mitk::Image::Pointer GetOutputAsImage();
 
     /** \brief Update the filter */
     void Update();
 
     /** \brief Set the Apodisation function to apply when beamforming */
-    void SetApodisation(float* apodisation, unsigned short apodArraySize)
+    void SetApodisation(const float* apodisation, unsigned short apodArraySize)
     {
       m_ApodArraySize = apodArraySize;
       m_Apodisation = apodisation;
     }
 
   protected:
 
     PhotoacousticOCLBeamformingFilter(BeamformingSettings::Pointer settings);
     virtual ~PhotoacousticOCLBeamformingFilter();
 
     /** \brief Initialize the filter */
     bool Initialize();
 
     /** \brief Updated the used data for beamforming depending on whether the configuration has significantly changed */
     void UpdateDataBuffers();
 
     /** \brief Execute the filter */
     void Execute();
 
     mitk::PixelType GetOutputType()
     {
       return mitk::MakeScalarPixelType<float>();
     }
 
     int GetBytesPerElem()
     {
       return sizeof(float);
     }
 
     virtual us::Module* GetModule();
 
   private:
     /** The OpenCL kernel for the filter */
     cl_kernel m_PixelCalculation;
 
     unsigned int m_OutputDim[3];
 
-    float* m_Apodisation;
+    const float* m_Apodisation;
     unsigned short m_ApodArraySize;
 
     unsigned short m_PAImage;
 
     BeamformingSettings::Pointer m_Conf;
 
     mitk::Image::Pointer m_InputImage;
 
     size_t m_ChunkSize[3];
 
     mitk::OCLUsedLinesCalculation::Pointer m_UsedLinesCalculation;
     mitk::OCLDelayCalculation::Pointer m_DelayCalculation;
 
     cl_mem m_ApodizationBuffer;
     cl_mem m_MemoryLocationsBuffer;
     cl_mem m_DelaysBuffer;
     cl_mem m_UsedLinesBuffer;
   };
 }
 #else
 namespace mitk
 {
   class PhotoacousticOCLBeamformingFilter : public itk::Object
   {
   public:
     mitkClassMacroItkParent(mitk::PhotoacousticOCLBeamformingFilter, itk::Object);
     itkNewMacro(Self);
 
   protected:
     /** Constructor */
     PhotoacousticOCLBeamformingFilter() {}
 
     /** Destructor */
     ~PhotoacousticOCLBeamformingFilter() override {}
   };
 }
 #endif
 #endif
diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingFilter.h b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingFilter.h
index 667432fff1..834b51dac1 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingFilter.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingFilter.h
@@ -1,102 +1,88 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
 #define MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
 
 #include "mitkImageToImageFilter.h"
 #include <functional>
 #include "./OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h"
 #include "mitkBeamformingSettings.h"
 #include "mitkBeamformingUtils.h"
 
 namespace mitk {
   /*!
   * \brief Class implementing an mitk::ImageToImageFilter for beamforming on both CPU and GPU
   *
   *  The class must be given a configuration class instance of mitk::BeamformingSettings for beamforming parameters through mitk::BeamformingFilter::Configure(BeamformingSettings settings)
   *  Whether the GPU is used can be set in the configuration.
   *  For significant problems or important messages a string is written, which can be accessed via GetMessageString().
   */
 
   class BeamformingFilter : public ImageToImageFilter
   {
   public:
     mitkClassMacro(BeamformingFilter, ImageToImageFilter);
 
     mitkNewMacro1Param(Self, mitk::BeamformingSettings::Pointer);
     itkCloneMacro(Self);
 
-    /** \brief Sets a new configuration to use
-    *
-    *  The Filter writes important messages that can be retrieved through this method; if nothing is to be reported, it returns "noMessage".
-    *  @return The message
-    */
-    std::string GetMessageString()
-    {
-      return m_Message;
-    }
-
     /** \brief Sets a callback for progress checking
     *
     *  An std::function<void(int, std::string)> can be set, through which progress of the currently updating filter is reported.
     *  The integer argument is a number between 0 an 100 to indicate how far completion has been achieved, the std::string argument indicates what the filter is currently doing.
     */
     void SetProgressHandle(std::function<void(int, std::string)> progressHandle);
 
   protected:
     BeamformingFilter(mitk::BeamformingSettings::Pointer settings);
 
     ~BeamformingFilter() override;
 
     void GenerateInputRequestedRegion() override;
 
     void GenerateOutputInformation() override;
 
     void GenerateData() override;
 
     //##Description
     //## @brief Time when Header was last initialized
     itk::TimeStamp m_TimeOfHeaderInitialization;
 
     /** \brief The std::function<void(int, std::string)>, through which progress of the currently updating filter is reported.
     */
     std::function<void(int, std::string)> m_ProgressHandle;
 
     float* m_OutputData;
     float* m_InputData;
     float* m_InputDataPuffer;
 
     /** \brief Current configuration set
     */
     BeamformingSettings::Pointer m_Conf;
 
     /**
     * The size of the apodization array when it last changed.
     */
     int m_LastApodizationArraySize;
 
     /** \brief Pointer to the GPU beamforming filter class; for performance reasons the filter is initialized within the constructor and kept for all later computations.
     */
     mitk::PhotoacousticOCLBeamformingFilter::Pointer m_BeamformingOclFilter;
-
-    /** \brief The message returned by mitk::BeamformingFilter::GetMessageString()
-    */
-    std::string m_Message;
   };
 } // namespace mitk
 
 #endif //MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingSettings.h b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingSettings.h
index 8028b9ca7c..711710a13b 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingSettings.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingSettings.h
@@ -1,253 +1,251 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef MITK_BEAMFORMING_SETTINGS
 #define MITK_BEAMFORMING_SETTINGS
 
 #include <itkObject.h>
 #include <itkMacro.h>
-//#include <mitkBeamformingUtils.h>
+#include <mitkCommon.h>
+#include <MitkPhotoacousticsAlgorithmsExports.h>
 
 namespace mitk {
   /*!
   * \brief Class holding the configuration data for the beamforming filters mitk::BeamformingFilter and mitk::PhotoacousticOCLBeamformingFilter
   *
   * A detailed description can be seen below. All parameters should be set manually for successfull beamforming.
   */
 
-  class BeamformingSettings : public itk::Object
+  class MITKPHOTOACOUSTICSALGORITHMS_EXPORT BeamformingSettings : public itk::Object
   {
   public:
-    mitkClassMacroItkParent(BeamformingSettings, itk::Object)
+    mitkClassMacroItkParent(BeamformingSettings, itk::Object);
+    mitkNewMacro1Param(BeamformingSettings, std::string);
+    itkCloneMacro(Self);
 
-      itkFactorylessNewMacro(Self)
-      itkCloneMacro(Self)
-
-      /** \brief Available delay calculation methods:
-      * - Spherical delay for best results.
-      * - A quadratic Taylor approximation for slightly faster results with hardly any quality loss.
-      */
-      enum DelayCalc { QuadApprox, Spherical };
+    /** \brief Available delay calculation methods:
+    * - Spherical delay for best results.
+    * - A quadratic Taylor approximation for slightly faster results with hardly any quality loss.
+    */
+    enum DelayCalc { QuadApprox, Spherical };
 
     /** \brief Available apodization functions:
     * - Hamming function.
     * - Von-Hann function.
     * - Box function.
     */
     enum Apodization { Hamm, Hann, Box };
 
     /** \brief Available beamforming algorithms:
     * - DAS (Delay and sum).
     * - DMAS (Delay multiply and sum).
     */
     enum BeamformingAlgorithm { DMAS, DAS, sDMAS };
 
-    itkGetMacro(PitchInMeters, float)
-      itkSetMacro(PitchInMeters, float)
-      itkGetMacro(SpeedOfSound, float)
-      itkSetMacro(SpeedOfSound, float)
-      itkGetMacro(TimeSpacing, float)
-      itkSetMacro(TimeSpacing, float)
-      itkGetMacro(Angle, float)
-      itkSetMacro(Angle, float)
-      itkGetMacro(IsPhotoacousticImage, bool)
-      itkSetMacro(IsPhotoacousticImage, bool)
-      itkGetMacro(TransducerElements, unsigned short)
-      itkSetMacro(TransducerElements, unsigned short)
-      itkGetMacro(SamplesPerLine, unsigned int)
-      itkSetMacro(SamplesPerLine, unsigned int)
-      itkGetMacro(ReconstructionLines, unsigned int)
-      itkSetMacro(ReconstructionLines, unsigned int)
-      itkGetMacro(UpperCutoff, unsigned int)
-      itkSetMacro(UpperCutoff, unsigned int)
-      itkGetMacro(Partial, bool)
-      itkSetMacro(Partial, bool)
-      itkGetMacro(CropBounds, unsigned int*)
-      void SetCropBounds(unsigned int* cropBounds)
-    {
-      if (m_CropBounds != nullptr)
-      {
-        delete[] m_CropBounds;
-      }
-
-      m_CropBounds = cropBounds;
-    }
-    itkGetMacro(InputDim, unsigned int*)
-      void SetInputDim(unsigned int* inputDim)
-    {
-      if (m_InputDim != nullptr)
-      {
-        delete[] m_InputDim;
-      }
-
-      m_InputDim = inputDim;
-    }
-    itkGetMacro(UseGPU, bool)
-      itkSetMacro(UseGPU, bool)
-      itkGetMacro(DelayCalculationMethod, DelayCalc)
-      itkSetMacro(DelayCalculationMethod, DelayCalc)
-      itkGetMacro(ApodizationFunction, float*)
-      void SetApodizationFunction(float* function)
-    {
-      if (m_ApodizationFunction != nullptr)
-      {
-        delete[] m_ApodizationFunction;
-      }
-
-      m_ApodizationFunction = function;
-    }
-    itkGetMacro(Apod, Apodization)
-      itkSetMacro(Apod, Apodization)
-      itkGetMacro(ApodizationArraySize, int)
-      itkSetMacro(ApodizationArraySize, int)
-      itkGetMacro(Algorithm, BeamformingAlgorithm)
-      itkSetMacro(Algorithm, BeamformingAlgorithm)
-      itkGetMacro(UseBP, bool)
-      itkSetMacro(UseBP, bool)
-      itkGetMacro(BPHighPass, float)
-      itkSetMacro(BPHighPass, float)
-      itkGetMacro(BPLowPass, float)
-      itkSetMacro(BPLowPass, float)
-
-      /** \brief function for mitk::PhotoacousticOCLBeamformingFilter to check whether buffers need to be updated
-      * this method only checks parameters relevant for the openCL implementation
-      */
-      static bool SettingsChangedOpenCL(const BeamformingSettings::Pointer lhs, const BeamformingSettings::Pointer rhs)
+    itkGetConstMacro(PitchInMeters, float);
+    itkGetConstMacro(SpeedOfSound, float);
+    itkGetConstMacro(TimeSpacing, float);
+    itkGetConstMacro(Angle, float);
+    itkGetConstMacro(IsPhotoacousticImage, bool);
+    itkGetConstMacro(TransducerElements, unsigned int);
+    itkGetConstMacro(SamplesPerLine, unsigned int);
+    itkGetConstMacro(ReconstructionLines, unsigned int);
+    itkGetConstMacro(UpperCutoff, unsigned int);
+    itkGetConstMacro(Partial, bool);
+    itkGetConstMacro(CropBounds, const unsigned int*);
+    itkGetConstMacro(InputDim, const unsigned int*);
+    itkGetConstMacro(UseGPU, bool);
+    itkGetConstMacro(DelayCalculationMethod, DelayCalc);
+    itkGetConstMacro(ApodizationFunction, const float*);
+    itkGetConstMacro(Apod, Apodization);
+    itkGetConstMacro(ApodizationArraySize, int);
+    itkGetConstMacro(Algorithm, BeamformingAlgorithm);
+    itkGetConstMacro(UseBP, bool);
+    itkGetConstMacro(BPHighPass, float);
+    itkGetConstMacro(BPLowPass, float);
+
+    /** \brief function for mitk::PhotoacousticOCLBeamformingFilter to check whether buffers need to be updated
+    * this method only checks parameters relevant for the openCL implementation
+    */
+    static bool SettingsChangedOpenCL(const BeamformingSettings::Pointer lhs, const BeamformingSettings::Pointer rhs)
     {
       return !((abs(lhs->GetAngle() - rhs->GetAngle()) < 0.01f) && // 0.01 degree error margin
         (lhs->GetApod() == rhs->GetApod()) &&
         (lhs->GetDelayCalculationMethod() == rhs->GetDelayCalculationMethod()) &&
         (lhs->GetIsPhotoacousticImage() == rhs->GetIsPhotoacousticImage()) &&
         (abs(lhs->GetPitchInMeters() - rhs->GetPitchInMeters()) < 0.000001f) && // 0.0001 mm error margin
         (lhs->GetReconstructionLines() == rhs->GetReconstructionLines()) &&
         (lhs->GetSamplesPerLine() == rhs->GetSamplesPerLine()) &&
         (abs(lhs->GetSpeedOfSound() - rhs->GetSpeedOfSound()) < 0.01f) &&
         (abs(lhs->GetTimeSpacing() - rhs->GetTimeSpacing()) < 0.00000000001f) && //0.01 ns error margin
         (lhs->GetTransducerElements() == rhs->GetTransducerElements()));
     }
 
-  protected:
-
-    BeamformingSettings()
-    {
-      m_InputDim = new unsigned int[3]{ 1, 1, 1 };
-      m_CropBounds = new unsigned int[2]{ 0, 0 };
-      m_ApodizationFunction = new float[m_ApodizationArraySize];
-
-      /*switch (GetApod())
-      {
-      case BeamformingSettings::Apodization::Hann:
-        SetApodizationFunction(mitk::BeamformingUtils::VonHannFunction(GetApodizationArraySize()));
-        break;
-      case BeamformingSettings::Apodization::Hamm:
-        SetApodizationFunction(mitk::BeamformingUtils::HammFunction(GetApodizationArraySize()));
-        break;
-      case BeamformingSettings::Apodization::Box:
-        SetApodizationFunction(mitk::BeamformingUtils::BoxFunction(GetApodizationArraySize()));
-        break;
-      default:
-        SetApodizationFunction(mitk::BeamformingUtils::BoxFunction(GetApodizationArraySize()));
-        break;
-      }*/
-    }
-    ~BeamformingSettings()
+    static Pointer New(float pitchInMeters,
+      float speedOfSound,
+      float timeSpacing,
+      float angle,
+      bool isPhotoacousticImage,
+      unsigned int transducerElements,
+      unsigned int upperCutoff,
+      bool partial,
+      unsigned int* cropBounds,
+      unsigned int* inputDim,
+      bool useGPU,
+      DelayCalc delayCalculationMethod,
+      Apodization apod,
+      unsigned int apodizationArraySize,
+      BeamformingAlgorithm algorithm,
+      bool useBP,
+      float BPHighPass,
+      float BPLowPass)
     {
+      Pointer smartPtr = new BeamformingSettings(pitchInMeters,
+        speedOfSound,
+        timeSpacing,
+        angle,
+        isPhotoacousticImage,
+        transducerElements,
+        upperCutoff,
+        partial,
+        cropBounds,
+        inputDim,
+        useGPU,
+        delayCalculationMethod,
+        apod,
+        apodizationArraySize,
+        algorithm,
+        useBP,
+        BPHighPass,
+        BPLowPass);
+      smartPtr->UnRegister();
+      return smartPtr;
     }
 
+  protected:
+
+    /**
+    */
+    BeamformingSettings(std::string xmlFile);
+
+    /**
+    */
+    BeamformingSettings(float pitchInMeters,
+      float speedOfSound,
+      float timeSpacing,
+      float angle,
+      bool isPhotoacousticImage,
+      unsigned int transducerElements,
+      unsigned int upperCutoff,
+      bool partial,
+      unsigned int* cropBounds,
+      unsigned int* inputDim,
+      bool useGPU,
+      DelayCalc delayCalculationMethod,
+      Apodization apod,
+      unsigned int apodizationArraySize,
+      BeamformingAlgorithm algorithm,
+      bool useBP,
+      float BPHighPass,
+      float BPLowPass
+    );
+
+    ~BeamformingSettings();
+
     /** \brief Pitch of the used transducer in [m].
     */
-    float m_PitchInMeters = 0.0003;
+    float m_PitchInMeters;
 
     /** \brief Speed of sound in the used medium in [m/s].
     */
-    float m_SpeedOfSound = 1540;
+    float m_SpeedOfSound;
 
     /** \brief The time spacing of the input image
     */
-    float m_TimeSpacing = 0.0000000000001; // [s]
+    float m_TimeSpacing; // [s]
 
     /** \brief The angle of the transducer elements
     */
-    float m_Angle = -1;
+    float m_Angle;
 
     /** \brief Flag whether processed image is a photoacoustic image or an ultrasound image
     */
-    bool m_IsPhotoacousticImage = true;
+    bool m_IsPhotoacousticImage;
 
     /** \brief How many transducer elements the used transducer had.
     */
-    unsigned short m_TransducerElements = 128;
+    unsigned int m_TransducerElements;
 
     /** \brief How many vertical samples should be used in the final image.
     */
-    unsigned int m_SamplesPerLine = 2048;
+    unsigned int m_SamplesPerLine;
 
     /** \brief How many lines should be reconstructed in the final image.
     */
-    unsigned int m_ReconstructionLines = 128;
+    unsigned int m_ReconstructionLines;
 
     /** \brief Sets how many voxels should be cut off from the top of the image before beamforming, to potentially avoid artifacts.
     */
-    unsigned int m_UpperCutoff = 0;
+    unsigned int m_UpperCutoff;
 
     /** \brief Sets whether only the slices selected by mitk::BeamformingSettings::CropBounds should be beamformed.
     */
-    bool m_Partial = false;
+    bool m_Partial;
 
     /** \brief Sets the first and last slice to be beamformed.
     */
-    unsigned int* m_CropBounds;
+    const unsigned int* m_CropBounds;
 
     /** \brief Sets the dimensions of the inputImage.
     */
-    unsigned int* m_InputDim;
+    const unsigned int* m_InputDim;
 
     /** \brief Decides whether GPU computing should be used
     */
-    bool m_UseGPU = false;
+    bool m_UseGPU;
 
     /** \brief Sets how the delays for beamforming should be calculated.
     */
-    DelayCalc m_DelayCalculationMethod = QuadApprox;
+    DelayCalc m_DelayCalculationMethod;
 
-    float* m_ApodizationFunction;
+    const float* m_ApodizationFunction;
 
     /** \brief Sets the used apodization function.
     */
-    Apodization m_Apod = Hann;
+    Apodization m_Apod;
 
     /** \brief Sets the resolution of the apodization array (must be greater than 0).
     */
-    int m_ApodizationArraySize = 128;
+    int m_ApodizationArraySize;
 
     /** \brief Sets the used beamforming algorithm.
     */
-    BeamformingAlgorithm m_Algorithm = DAS;
+    BeamformingAlgorithm m_Algorithm;
 
     /** \brief Sets whether after beamforming a bandpass should be automatically applied
     */
-    bool m_UseBP = false;
+    bool m_UseBP;
 
     /** \brief Sets the position at which lower frequencies are completely cut off in Hz.
     */
-    float m_BPHighPass = 50;
+    float m_BPHighPass;
 
     /** \brief Sets the position at which higher frequencies are completely cut off in Hz.
     */
-    float m_BPLowPass = 50;
+    float m_BPLowPass;
   };
 }
 #endif //MITK_BEAMFORMING_SETTINGS
diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingUtils.h b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingUtils.h
index ead7f821cf..9060284cfd 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingUtils.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkBeamformingUtils.h
@@ -1,80 +1,80 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef MITK_BEAMFORMING_FILTER_UTILS
 #define MITK_BEAMFORMING_FILTER_UTILS
 
 #include "mitkImageToImageFilter.h"
 #include <functional>
 #include "./OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h"
 #include "mitkBeamformingSettings.h"
 
 namespace mitk {
   /*!
   * \brief Class implementing util functionality for beamforming on CPU
   *
   */
   class BeamformingUtils final
   {
   public:
 
     /** \brief Function to perform beamforming on CPU for a single line, using DAS and quadratic delay
    */
-    static void DASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void DASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Function to perform beamforming on CPU for a single line, using DAS and spherical delay
     */
-    static void DASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void DASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Function to perform beamforming on CPU for a single line, using DMAS and quadratic delay
     */
-    static void DMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void DMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Function to perform beamforming on CPU for a single line, using DMAS and spherical delay
     */
-    static void DMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void DMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Function to perform beamforming on CPU for a single line, using signed DMAS and quadratic delay
     */
-    static void sDMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void sDMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Function to perform beamforming on CPU for a single line, using signed DMAS and spherical delay
     */
-    static void sDMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize, const mitk::BeamformingSettings::Pointer config);
+    static void sDMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, const mitk::BeamformingSettings::Pointer config);
 
     /** \brief Pointer holding the Von-Hann apodization window for beamforming
     * @param samples the resolution at which the window is created
     */
     static float* VonHannFunction(int samples);
 
     /** \brief Function to create a Hamming apodization window
     * @param samples the resolution at which the window is created
     */
     static float* HammFunction(int samples);
 
     /** \brief Function to create a Box apodization window
     * @param samples the resolution at which the window is created
     */
     static float* BoxFunction(int samples);
 
   protected:
     BeamformingUtils();
 
     ~BeamformingUtils();
   };
 } // namespace mitk
 
 #endif //MITK_BEAMFORMING_FILTER_UTILS
diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h b/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
index 26bed5e04f..0c017de1ff 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
@@ -1,132 +1,131 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef mitkPhotoacousticFilterService_H_HEADER_INCLUDED
 #define mitkPhotoacousticFilterService_H_HEADER_INCLUDED
 
 #include "itkObject.h"
 #include "mitkCommon.h"
 #include "mitkImage.h"
 #include <functional>
 
 #include "mitkBeamformingSettings.h"
 #include "mitkBeamformingFilter.h"
 #include "MitkPhotoacousticsAlgorithmsExports.h"
 
 namespace mitk {
   /*!
   * \brief Class holding methods to apply all Filters within the Photoacoustics Algorithms Module
   *
   *  Implemented are:
   *  - A B-Mode Filter
   *  - A Resampling Filter
   *  - Beamforming on GPU and CPU
   *  - A Bandpass Filter
   */
 
   class MITKPHOTOACOUSTICSALGORITHMS_EXPORT PhotoacousticFilterService : public itk::Object
   {
   public:
     mitkClassMacroItkParent(mitk::PhotoacousticFilterService, itk::Object);
     itkFactorylessNewMacro(Self);
     /** \brief Defines the methods for the B-Mode filter
     * Currently implemented are an Envelope Detection filter and a simple Absolute filter.
     */
     enum BModeMethod { EnvelopeDetection, Abs };
 
     /** \brief Applies a B-Mode Filter
     *
     * Applies a B-Mode filter using the given parameters.
     * @param inputImage The image to be processed.
     * @param method The kind of B-Mode Filter to be used.
     * @param UseGPU Setting this to true will allow the Filter to use the GPU.
     * @param UseLogFilter Setting this to true will apply a simple logarithm to the image after the B-Mode Filter has been applied.
     * @param resampleSpacing If this is set to 0, nothing will be done; otherwise, the image is resampled to a spacing of resampleSpacing mm per pixel.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer ApplyBmodeFilter(mitk::Image::Pointer inputImage, BModeMethod method = BModeMethod::Abs, bool UseGPU = false, bool UseLogFilter = false, float resampleSpacing = 0.15);
 
     // mitk::Image::Pointer ApplyScatteringCompensation(mitk::Image::Pointer inputImage, int scatteringCoefficient);
 
     /** \brief Resamples the given image
     *
     * Resamples an image using the given parameters.
     * @param inputImage The image to be processed.
     * @param outputSize An array of dimensions the image should be resampled to.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer ApplyResampling(mitk::Image::Pointer inputImage, unsigned int outputSize[2]);
 
     /** \brief Beamforms the given image
     *
     * Resamples an image using the given parameters.
     * @param inputImage The image to be processed.
     * @param config The configuration set to be used for beamforming.
-    * @param message A string into which potentially critical messages will be written.
     * @param progressHandle An std::function<void(int, std::string)>, through which progress of the currently updating filter is reported.
     * The integer argument is a number between 0 an 100 to indicate how far completion has been achieved, the std::string argument indicates what the filter is currently doing.
     * @return The processed image is returned after the filter has finished.
     */
-    mitk::Image::Pointer ApplyBeamforming(mitk::Image::Pointer inputImage, BeamformingSettings::Pointer config, std::string& message, std::function<void(int, std::string)> progressHandle = [](int, std::string) {});
+    mitk::Image::Pointer ApplyBeamforming(mitk::Image::Pointer inputImage, BeamformingSettings::Pointer config, std::function<void(int, std::string)> progressHandle = [](int, std::string) {});
 
     /** \brief Crops the given image
     *
     * Crops an image in 3 dimension using the given parameters.
     * @param inputImage The image to be processed.
     * @param above How many voxels will be cut from the top of the image.
     * @param below How many voxels will be cut from the bottom of the image.
     * @param right How many voxels will be cut from the right side of the image.
     * @param left How many voxels will be cut from the left side of the image.
     * @param minSlice The first slice to be present in the resulting image.
     * @param maxSlice The last slice to be present in the resulting image.
     * @return The processed image is returned after the filter has finished. For the purposes of this module, the returned image is always of type float.
     */
     mitk::Image::Pointer ApplyCropping(mitk::Image::Pointer inputImage, int above, int below, int right, int left, int minSlice, int maxSlice);
 
     /** \brief Applies a Bandpass filter to the given image
     *
     * Applies a bandpass filter to the given image using the given parameters.
     * @param data The image to be processed.
     * @param recordTime The depth of the image in seconds.
     * @param BPHighPass The position at which Lower frequencies are completely cut off in Hz.
     * @param BPLowPass The position at which Higher frequencies are completely cut off in Hz.
     * @param alphaHighPass The high pass tukey window parameter to control the shape of the bandpass filter: 0 will make it a Box function, 1 a Hann function. alpha can be set between those two bounds.
     * @param alphaLowPass The low passtukey window parameter to control the shape of the bandpass filter: 0 will make it a Box function, 1 a Hann function. alpha can be set between those two bounds.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer BandpassFilter(mitk::Image::Pointer data, float recordTime,
       float BPHighPass, float BPLowPass,
       float alphaHighPass, float alphaLowPass);
 
   protected:
     PhotoacousticFilterService();
     ~PhotoacousticFilterService() override;
 
     /** \brief
       For performance reasons, an instance of the Beamforming filter is initialized as soon as possible and kept for all further uses.
     */
     mitk::BeamformingFilter::Pointer m_BeamformingFilter;
 
     /** \brief Function that creates a Tukey function for the bandpass
     */
     itk::Image<float, 3U>::Pointer BPFunction(mitk::Image::Pointer reference,
       int cutoffFrequencyPixelHighPass,
       int cutoffFrequencyPixelLowPass,
       float alphaHighPass, float alphaLowPass);
   };
 } // namespace mitk
 
 #endif /* mitkPhotoacousticFilterService_H_HEADER_INCLUDED */
diff --git a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
index 341375c8a7..6a5eb4a76c 100644
--- a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
@@ -1,273 +1,260 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if defined(PHOTOACOUSTICS_USE_GPU) || DOXYGEN
 
 #include "./OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.h"
 #include "usServiceReference.h"
 
 mitk::PhotoacousticOCLBeamformingFilter::PhotoacousticOCLBeamformingFilter(BeamformingSettings::Pointer settings) :
   m_PixelCalculation(NULL),
   m_InputImage(mitk::Image::New()),
   m_ApodizationBuffer(nullptr),
   m_MemoryLocationsBuffer(nullptr),
   m_DelaysBuffer(nullptr),
   m_UsedLinesBuffer(nullptr),
   m_Conf(settings)
 {
+  MITK_INFO << "Initializing OCL beamforming Filter...";
   this->AddSourceFile("DAS.cl");
   this->AddSourceFile("DMAS.cl");
   this->AddSourceFile("sDMAS.cl");
   this->m_FilterID = "OpenCLBeamformingFilter";
 
   this->Initialize();
 
   unsigned int dim[] = { 128, 2048, 2 };
 
-  mitk::Vector3D spacing;
-  spacing[0] = 1;
-  spacing[1] = 1;
-  spacing[2] = 1;
-
   m_InputImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, dim);
-  m_InputImage->SetSpacing(spacing);
 
   m_ChunkSize[0] = 128;
   m_ChunkSize[1] = 128;
   m_ChunkSize[2] = 8;
 
   m_UsedLinesCalculation = mitk::OCLUsedLinesCalculation::New(m_Conf);
   m_DelayCalculation = mitk::OCLDelayCalculation::New(m_Conf);
+  MITK_INFO << "Initializing OCL beamforming Filter...[Done]";
 }
 
 mitk::PhotoacousticOCLBeamformingFilter::~PhotoacousticOCLBeamformingFilter()
 {
   if (this->m_PixelCalculation)
   {
     clReleaseKernel(m_PixelCalculation);
   }
 
   if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::Update()
 {
   //Check if context & program available
   if (!this->Initialize())
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // clean-up also the resources
     resources->InvalidateStorage();
     mitkThrow() << "Filter is not initialized. Cannot update.";
   }
   else {
     // Execute
     this->Execute();
   }
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::UpdateDataBuffers()
 {
   /*us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
   cl_ulong globalMemSize = oclGetGlobalMemSize(resources->GetCurrentDevice());*/
   //Initialize the Output
 
   try
   {
     MITK_INFO << "Updating Workgroup size for new dimensions";
     size_t outputSize = (size_t)m_Conf->GetReconstructionLines() * (size_t)m_Conf->GetSamplesPerLine() *
       (size_t)m_Conf->GetInputDim()[2];
     m_OutputDim[0] = m_Conf->GetReconstructionLines();
     m_OutputDim[1] = m_Conf->GetSamplesPerLine();
     m_OutputDim[2] = m_Conf->GetInputDim()[2];
     this->InitExec(this->m_PixelCalculation, m_OutputDim, outputSize, sizeof(float));
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Caught exception while initializing filter: " << e.what();
     return;
   }
 
   //TODO FIXME
   cl_int clErr = 0;
   MITK_DEBUG << "Updating GPU Buffers for new configuration";
 
   // create the apodisation buffer
 
   if (m_Apodisation == nullptr)
   {
     MITK_INFO << "No apodisation function set; Beamforming will be done without any apodisation.";
-    m_Apodisation = new float[1];
-    m_Apodisation[0] = 1;
+    m_Apodisation = new float[1]{ 1 };
     m_ApodArraySize = 1;
   }
 
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
   cl_context gpuContext = resources->GetContext();
 
   if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
 
-  this->m_ApodizationBuffer = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_ApodArraySize, m_Apodisation, &clErr);
+  this->m_ApodizationBuffer = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_ApodArraySize, const_cast<float*>(m_Apodisation), &clErr);
   CHECK_OCL_ERR(clErr);
 
   // calculate used lines
 
   m_UsedLinesCalculation->Update();
   m_UsedLinesBuffer = m_UsedLinesCalculation->GetGPUOutput()->GetGPUBuffer();
 
   // calculate the Delays
   m_DelayCalculation->SetInputs(m_UsedLinesBuffer);
   m_DelayCalculation->Update();
 
   m_DelaysBuffer = m_DelayCalculation->GetGPUOutput()->GetGPUBuffer();
 
   //m_ConfOld = m_Conf;
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::Execute()
 {
   cl_int clErr = 0;
   UpdateDataBuffers();
 
   unsigned int reconstructionLines = this->m_Conf->GetReconstructionLines();
   unsigned int samplesPerLine = this->m_Conf->GetSamplesPerLine();
 
   clErr = clSetKernelArg(this->m_PixelCalculation, 2, sizeof(cl_mem), &(this->m_UsedLinesBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 3, sizeof(cl_mem), &(this->m_DelaysBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 4, sizeof(cl_mem), &(this->m_ApodizationBuffer));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 5, sizeof(cl_ushort), &(this->m_ApodArraySize));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 6, sizeof(cl_uint), &(this->m_Conf->GetInputDim()[0]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 7, sizeof(cl_uint), &(this->m_Conf->GetInputDim()[1]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 8, sizeof(cl_uint), &(this->m_Conf->GetInputDim()[2]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 9, sizeof(cl_uint), &(reconstructionLines));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 10, sizeof(cl_uint), &(samplesPerLine));
 
   // execute the filter on a 3D NDRange
   if (m_OutputDim[2] == 1 || m_ChunkSize[2] == 1)
   {
     if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 2, m_ChunkSize, 16, 50))
       mitkThrow() << "openCL Error when executing Kernel";
   }
   else
   {
     if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 3, m_ChunkSize, 16, 50))
       mitkThrow() << "openCL Error when executing Kernel";
   }
 
   // signalize the GPU-side data changed
   m_Output->Modified(GPU_DATA);
 }
 
 us::Module *mitk::PhotoacousticOCLBeamformingFilter::GetModule()
 {
   return us::GetModuleContext()->GetModule();
 }
 
 bool mitk::PhotoacousticOCLBeamformingFilter::Initialize()
 {
   MITK_INFO << "Initializing OCL Beamforming Filter...";
   bool buildErr = true;
   cl_int clErr = 0;
 
   if (OclFilter::Initialize())
   {
     switch (m_Conf->GetAlgorithm())
     {
     case BeamformingSettings::BeamformingAlgorithm::DAS:
     {
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS", &clErr);
       break;
     }
     case BeamformingSettings::BeamformingAlgorithm::DMAS:
     {
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMAS", &clErr);
       break;
     }
     case BeamformingSettings::BeamformingAlgorithm::sDMAS:
     {
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "cksDMAS", &clErr);
       break;
     }
     default:
     {
       MITK_INFO << "No beamforming algorithm specified, setting to DAS";
       this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS", &clErr);
       break;
     }
     }
     buildErr |= CHECK_OCL_ERR(clErr);
   }
 
   CHECK_OCL_ERR(clErr);
 
   MITK_INFO << "Initializing OCL Beamforming Filter...[Done]";
 
   return (OclFilter::IsInitialized() && buildErr);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(mitk::Image::Pointer image)
 {
   OclDataSetToDataSetFilter::SetInput(image);
-
   m_InputImage = image;
-  m_Conf->GetInputDim()[0] = m_InputImage->GetDimension(0);
-  m_Conf->GetInputDim()[1] = m_InputImage->GetDimension(1);
-  m_Conf->GetInputDim()[2] = m_InputImage->GetDimension(2);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(void* data, unsigned int* dimensions, unsigned int BpE)
 {
   OclDataSetToDataSetFilter::SetInput(data, dimensions[0] * dimensions[1] * dimensions[2], BpE);
-
-  m_Conf->GetInputDim()[0] = dimensions[0];
-  m_Conf->GetInputDim()[1] = dimensions[1];
-  m_Conf->GetInputDim()[2] = dimensions[2];
 }
 
 mitk::Image::Pointer mitk::PhotoacousticOCLBeamformingFilter::GetOutputAsImage()
 {
   mitk::Image::Pointer outputImage = mitk::Image::New();
 
   if (m_Output->IsModified(GPU_DATA))
   {
     void* pData = m_Output->TransferDataToCPU(m_CommandQue);
 
     const unsigned int dimension = 3;
     unsigned int dimensions[3] = { (unsigned int)m_OutputDim[0], (unsigned int)m_OutputDim[1], (unsigned int)m_OutputDim[2] };
 
     const mitk::SlicedGeometry3D::Pointer p_slg = m_InputImage->GetSlicedGeometry();
 
     MITK_DEBUG << "Creating new MITK Image.";
 
     outputImage->Initialize(this->GetOutputType(), dimension, dimensions);
     outputImage->SetSpacing(p_slg->GetSpacing());
     outputImage->SetImportVolume(pData, 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory);
   }
 
   MITK_DEBUG << "Image Initialized.";
 
   return outputImage;
 }
 
 void* mitk::PhotoacousticOCLBeamformingFilter::GetOutput()
 {
   return OclDataSetToDataSetFilter::GetOutput();
 }
 #endif
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingFilter.cpp
index cd63d9df49..c53ea9da18 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingFilter.cpp
@@ -1,305 +1,298 @@
 /*===================================================================
-mitkPhotoacousticBeamformingFilter
+mitkBeamformingFilter
 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 "mitkProperties.h"
 #include "mitkImageReadAccessor.h"
 #include <algorithm>
 #include <itkImageIOBase.h>
 #include <chrono>
 #include <thread>
 #include <itkImageIOBase.h>
 #include "mitkImageCast.h"
 #include "mitkBeamformingFilter.h"
 #include "mitkBeamformingUtils.h"
 
 mitk::BeamformingFilter::BeamformingFilter(mitk::BeamformingSettings::Pointer settings) :
   m_OutputData(nullptr),
   m_InputData(nullptr),
-  m_Message("noMessage"),
   m_Conf(settings)
 {
   MITK_INFO << "Instantiating BeamformingFilter...";
   this->SetNumberOfIndexedInputs(1);
   this->SetNumberOfRequiredInputs(1);
 
   m_ProgressHandle = [](int, std::string) {};
 
   m_BeamformingOclFilter = mitk::PhotoacousticOCLBeamformingFilter::New(m_Conf);
 
   MITK_INFO << "Instantiating BeamformingFilter...[Done]";
 }
 
 void mitk::BeamformingFilter::SetProgressHandle(std::function<void(int, std::string)> progressHandle)
 {
   m_ProgressHandle = progressHandle;
 }
 
 mitk::BeamformingFilter::~BeamformingFilter()
 {
   MITK_INFO << "Destructed BeamformingFilter";
 }
 
 void mitk::BeamformingFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* output = this->GetOutput();
   mitk::Image* input = const_cast<mitk::Image *> (this->GetInput());
   if (!output->IsInitialized())
   {
     return;
   }
 
   input->SetRequestedRegionToLargestPossibleRegion();
 }
 
 void mitk::BeamformingFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   unsigned int dim[] = { m_Conf->GetReconstructionLines(), m_Conf->GetSamplesPerLine(), input->GetDimension(2) };
   output->Initialize(mitk::MakeScalarPixelType<float>(), 3, dim);
 
   mitk::Vector3D spacing;
   spacing[0] = m_Conf->GetPitchInMeters() * m_Conf->GetTransducerElements() * 1000 / m_Conf->GetReconstructionLines();
   spacing[1] = (m_Conf->GetTimeSpacing() * m_Conf->GetInputDim()[1]) / 2 * m_Conf->GetSpeedOfSound() * 1000 / m_Conf->GetSamplesPerLine();
   spacing[2] = 1;
 
   output->GetGeometry()->SetSpacing(spacing);
   output->GetGeometry()->Modified();
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::BeamformingFilter::GenerateData()
 {
   mitk::Image::Pointer input = this->GetInput();
   if (!(input->GetPixelType().GetTypeAsString() == "scalar (float)" || input->GetPixelType().GetTypeAsString() == " (float)"))
   {
+    MITK_ERROR << "Pixel type of input needs to be float for this filter to work.";
     mitkThrow() << "Pixel type of input needs to be float for this filter to work.";
   }
 
   GenerateOutputInformation();
   mitk::Image::Pointer output = this->GetOutput();
 
   if (!output->IsInitialized())
     return;
 
   auto begin = std::chrono::high_resolution_clock::now(); // debbuging the performance...
 
   if (!m_Conf->GetUseGPU())
   {
     int progInterval = output->GetDimension(2) / 20 > 1 ? output->GetDimension(2) / 20 : 1;
     // the interval at which we update the gui progress bar
 
     float inputDim[2] = { (float)input->GetDimension(0), (float)input->GetDimension(1) };
     float outputDim[2] = { (float)output->GetDimension(0), (float)output->GetDimension(1) };
 
     for (unsigned int i = 0; i < output->GetDimension(2); ++i) // seperate Slices should get Beamforming seperately applied
     {
       mitk::ImageReadAccessor inputReadAccessor(input, input->GetSliceData(i));
       m_InputData = (float*)inputReadAccessor.GetData();
 
       m_OutputData = new float[m_Conf->GetReconstructionLines()*m_Conf->GetSamplesPerLine()];
 
       // fill the image with zeros
       for (int l = 0; l < outputDim[0]; ++l)
       {
         for (int s = 0; s < outputDim[1]; ++s)
         {
           m_OutputData[l*(short)outputDim[1] + s] = 0;
         }
       }
 
       std::thread *threads = new std::thread[(short)outputDim[0]];
 
       // every line will be beamformed in a seperate thread
       if (m_Conf->GetAlgorithm() == BeamformingSettings::BeamformingAlgorithm::DAS)
       {
         if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::QuadApprox)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::DASQuadraticLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
         else if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::Spherical)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::DASSphericalLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
       }
       else if (m_Conf->GetAlgorithm() == BeamformingSettings::BeamformingAlgorithm::DMAS)
       {
         if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::QuadApprox)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::DMASQuadraticLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
         else if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::Spherical)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::DMASSphericalLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
       }
       else if (m_Conf->GetAlgorithm() == BeamformingSettings::BeamformingAlgorithm::sDMAS)
       {
         if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::QuadApprox)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::sDMASQuadraticLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
         else if (m_Conf->GetDelayCalculationMethod() == BeamformingSettings::DelayCalc::Spherical)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingUtils::sDMASSphericalLine, m_InputData,
-              m_OutputData, inputDim, outputDim, line, m_Conf->GetApodizationFunction(),
-              m_Conf->GetApodizationArraySize(), m_Conf);
+              m_OutputData, inputDim, outputDim, line, m_Conf);
           }
         }
       }
       // wait for all lines to finish
       for (short line = 0; line < outputDim[0]; ++line)
       {
         threads[line].join();
       }
 
       output->SetSlice(m_OutputData, i);
 
       if (i % progInterval == 0)
         m_ProgressHandle((int)((i + 1) / (float)output->GetDimension(2) * 100), "performing reconstruction");
 
       delete[] m_OutputData;
       m_OutputData = nullptr;
       m_InputData = nullptr;
     }
   }
 #if defined(PHOTOACOUSTICS_USE_GPU) || DOXYGEN
   else
   {
     try
     {
       // first, we check whether the data is float, other formats are unsupported
       if (!(input->GetPixelType().GetTypeAsString() == "scalar (float)" || input->GetPixelType().GetTypeAsString() == " (float)"))
       {
         MITK_ERROR << "Pixel type is not float, abort";
         return;
       }
 
       unsigned long availableMemory = m_BeamformingOclFilter->GetDeviceMemory();
 
       unsigned int batchSize = 16;
       unsigned int batches = (unsigned int)((float)input->GetDimension(2) / batchSize) + (input->GetDimension(2) % batchSize > 0);
 
       unsigned int batchDim[] = { input->GetDimension(0), input->GetDimension(1), batchSize };
       unsigned int batchDimLast[] = { input->GetDimension(0), input->GetDimension(1), input->GetDimension(2) % batchSize };
 
       // the following safeguard is probably only needed for absurdly small GPU memory
       for (batchSize = 16;
         (unsigned long)batchSize *
         ((unsigned long)(batchDim[0] * batchDim[1]) * 4 + // single input image (float)
         (unsigned long)(m_Conf->GetReconstructionLines() * m_Conf->GetSamplesPerLine()) * 4) // single output image (float)
           > availableMemory -
         (unsigned long)(m_Conf->GetReconstructionLines() / 2 * m_Conf->GetSamplesPerLine()) * 2 - // Delays buffer (unsigned short)
         (unsigned long)(m_Conf->GetReconstructionLines() * m_Conf->GetSamplesPerLine()) * 3 * 2 - // UsedLines buffer (unsigned short)
         50 * 1024 * 1024; // 50 MB buffer for local data, system purposes etc
         --batchSize)
       {
       }
       if (batchSize < 1)
       {
         MITK_ERROR << "device memory too small for GPU beamforming";
         return;
       }
 
       mitk::ImageReadAccessor copy(input);
 
       for (unsigned int i = 0; i < batches; ++i)
       {
         m_ProgressHandle(input->GetDimension(2) / batches * i, "performing reconstruction");
 
         mitk::Image::Pointer inputBatch = mitk::Image::New();
+        unsigned int num_Slices = 1;
         if (i == batches - 1 && (input->GetDimension(2) % batchSize > 0))
         {
           inputBatch->Initialize(mitk::MakeScalarPixelType<float>(), 3, batchDimLast);
-          m_Conf->GetInputDim()[2] = batchDimLast[2];
+          num_Slices = batchDimLast[2];
         }
         else
         {
           inputBatch->Initialize(mitk::MakeScalarPixelType<float>(), 3, batchDim);
-          m_Conf->GetInputDim()[2] = batchDim[2];
+          num_Slices = batchDim[2];
         }
 
         inputBatch->SetSpacing(input->GetGeometry()->GetSpacing());
 
         inputBatch->SetImportVolume(&(((float*)copy.GetData())[input->GetDimension(0) * input->GetDimension(1) * batchSize * i]));
 
         m_BeamformingOclFilter->SetApodisation(m_Conf->GetApodizationFunction(), m_Conf->GetApodizationArraySize());
         m_BeamformingOclFilter->SetInput(inputBatch);
         m_BeamformingOclFilter->Update();
 
         void* out = m_BeamformingOclFilter->GetOutput();
 
-        for (unsigned int slice = 0; slice < m_Conf->GetInputDim()[2]; ++slice)
+        for (unsigned int slice = 0; slice < num_Slices; ++slice)
         {
           output->SetImportSlice(
             &(((float*)out)[m_Conf->GetReconstructionLines() * m_Conf->GetSamplesPerLine() * slice]),
             batchSize * i + slice, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
         }
       }
     }
     catch (mitk::Exception &e)
     {
       std::string errorMessage = "Caught unexpected exception ";
       errorMessage.append(e.what());
       MITK_ERROR << errorMessage;
 
       float* dummyData = new float[m_Conf->GetReconstructionLines() * m_Conf->GetSamplesPerLine() * m_Conf->GetInputDim()[2]];
-      output->SetImportVolume(dummyData, 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory);
-
-      m_Message = "An openCL error occurred; all GPU operations in this and the next session may be corrupted.";
+      output->SetImportVolume(dummyData, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
     }
   }
 #endif
   m_TimeOfHeaderInitialization.Modified();
 
   auto end = std::chrono::high_resolution_clock::now();
   MITK_INFO << "Beamforming of " << output->GetDimension(2) << " Images completed in " << ((float)std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count()) / 1000000 << "ms" << std::endl;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingSettings.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingSettings.cpp
new file mode 100644
index 0000000000..1b6313ffa0
--- /dev/null
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBeamformingSettings.cpp
@@ -0,0 +1,119 @@
+/*===================================================================
+mitkBeamformingSettings
+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 "mitkBeamformingSettings.h"
+#include "mitkBeamformingUtils.h"
+#include "itkMutexLock.h"
+
+mitk::BeamformingSettings::BeamformingSettings(std::string xmlFile)
+{
+  MITK_ERROR << "Not implemented yet.";
+  mitkThrow() << "Not implemented yet.";
+}
+
+mitk::BeamformingSettings::BeamformingSettings(float pitchInMeters,
+  float speedOfSound,
+  float timeSpacing,
+  float angle,
+  bool isPhotoacousticImage,
+  unsigned int transducerElements,
+  unsigned int upperCutoff,
+  bool partial,
+  unsigned int* cropBounds,
+  unsigned int* inputDim,
+  bool useGPU,
+  DelayCalc delayCalculationMethod,
+  Apodization apod,
+  unsigned int apodizationArraySize,
+  BeamformingAlgorithm algorithm,
+  bool useBP,
+  float BPHighPass,
+  float BPLowPass
+) :
+  m_PitchInMeters(pitchInMeters),
+  m_SpeedOfSound(speedOfSound),
+  m_TimeSpacing(timeSpacing),
+  m_Angle(angle),
+  m_IsPhotoacousticImage(isPhotoacousticImage),
+  m_TransducerElements(transducerElements),
+  m_UpperCutoff(upperCutoff),
+  m_Partial(partial),
+  m_CropBounds(cropBounds),
+  m_UseGPU(useGPU),
+  m_DelayCalculationMethod(delayCalculationMethod),
+  m_Apod(apod),
+  m_ApodizationArraySize(apodizationArraySize),
+  m_Algorithm(algorithm),
+  m_UseBP(useBP),
+  m_BPHighPass(BPHighPass),
+  m_BPLowPass(BPLowPass)
+{
+  if (inputDim == nullptr)
+  {
+    MITK_ERROR << "No input dimension given.";
+    mitkThrow() << "No input dimension given.";
+  }
+
+  switch (GetApod())
+  {
+  case BeamformingSettings::Apodization::Hann:
+    m_ApodizationFunction = mitk::BeamformingUtils::VonHannFunction(GetApodizationArraySize());
+    break;
+  case BeamformingSettings::Apodization::Hamm:
+    m_ApodizationFunction = mitk::BeamformingUtils::HammFunction(GetApodizationArraySize());
+    break;
+  case BeamformingSettings::Apodization::Box:
+  default:
+    m_ApodizationFunction = mitk::BeamformingUtils::BoxFunction(GetApodizationArraySize());
+    break;
+  }
+
+  if (m_CropBounds == nullptr)
+    m_CropBounds = new unsigned int[2]{ 0, 0 };
+
+  m_InputDim = new unsigned int[2]{ inputDim[0], inputDim[1] };
+
+  m_SamplesPerLine = m_InputDim[1];
+  m_ReconstructionLines = m_InputDim[0];
+}
+
+mitk::BeamformingSettings::~BeamformingSettings()
+{
+  MITK_INFO << "Destructing beamforming settings...";
+  //Free memory
+  if (m_ApodizationFunction != nullptr)
+  {
+    MITK_INFO << "Deleting apodization function...";
+    delete[] m_ApodizationFunction;
+    MITK_INFO << "Deleting apodization function...[Done]";
+  }
+
+  if (m_CropBounds != nullptr)
+  {
+    MITK_INFO << "Deleting crop bounds...";
+    delete[] m_CropBounds;
+    MITK_INFO << "Deleting crop bounds...[Done]";
+  }
+
+  if (m_InputDim != nullptr)
+  {
+    MITK_INFO << "Deleting input dim...";
+    delete[] m_InputDim;
+    MITK_INFO << "Deleting input dim...[Done]";
+  }
+
+  MITK_INFO << "Destructing beamforming settings...[Done]";
+}
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCastToFloatImageFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCastToFloatImageFilter.cpp
index b8d6e8e995..4809971115 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCastToFloatImageFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCastToFloatImageFilter.cpp
@@ -1,91 +1,92 @@
 /*===================================================================
 mitkCastToFloatImageFilter
 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 "mitkCastToFloatImageFilter.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkImageWriteAccessor.h"
 
 mitk::CastToFloatImageFilter::CastToFloatImageFilter()
 {
   MITK_INFO << "Instantiating CastToFloatImageFilter...";
   SetNumberOfIndexedInputs(1);
   SetNumberOfIndexedOutputs(1);
   MITK_INFO << "Instantiating CastToFloatImageFilter...[Done]";
 }
 
 mitk::CastToFloatImageFilter::~CastToFloatImageFilter()
 {
   MITK_INFO << "Destructed CastToFloatImageFilter.";
 }
 
 template<class TPixelType>
 float* CastData(const void* inputArray, unsigned long length)
 {
   float* outputArray = new float[length];
   for (unsigned long i = 0; i < length; ++i)
   {
     outputArray[i] = (float)((TPixelType*)inputArray)[i];
   }
   return outputArray;
 }
 
 void mitk::CastToFloatImageFilter::GenerateData()
 {
   mitk::Image::Pointer inputImage = GetInput();
   mitk::Image::Pointer outputImage = GetOutput();
 
   std::string type = inputImage->GetPixelType().GetTypeAsString();
 
   if (type == "scalar (float)" || type == " (float)")
   {
     outputImage->Initialize(mitk::MakeScalarPixelType<float>(), inputImage->GetDimension(), inputImage->GetDimensions());
     outputImage->SetSpacing(inputImage->GetGeometry()->GetSpacing());
     outputImage->SetImportVolume(mitk::ImageWriteAccessor(inputImage).GetData(), 0, 0, mitk::Image::ImportMemoryManagementType::RtlCopyMemory);
     MITK_INFO << "Input is already float type. Nothing to do here.";
     return;
   }
   if (outputImage.IsNull())
   {
     outputImage = mitk::Image::New();
   }
 
   unsigned long length = 1;
   for (unsigned int i = 0, limit = inputImage->GetDimension(); i < limit; ++i)
     length *= inputImage->GetDimensions()[i];
 
   float* outputData;
 
   mitk::ImageReadAccessor readAccess(inputImage);
 
   if (type == "scalar (short)" || type == " (short)")
     outputData = CastData<short>(readAccess.GetData(), length);
   else if (type == "scalar (unsigned short)" || type == " (unsigned short)" || type == " (unsigned_short)" || type == "scalar (unsigned_short)")
     outputData = CastData<unsigned short>(readAccess.GetData(), length);
   else if (type == "scalar (int)" || type == " (int)")
     outputData = CastData<int>(readAccess.GetData(), length);
   else if (type == "scalar (unsigned int)" || type == " (unsigned int)" || type == " (unsigned_int)" || type == "scalar (unsigned_int)")
     outputData = CastData<unsigned int>(readAccess.GetData(), length);
   else if (type == "scalar (double)" || type == " (double)")
     outputData = CastData<double>(readAccess.GetData(), length);
   else if (type == "scalar (long)" || type == " (long)")
     outputData = CastData<long>(readAccess.GetData(), length);
   else
     mitkThrow() << "The given image has a datatype that is not yet supported. Given datatype: " << type;
 
   outputImage->Initialize(mitk::MakeScalarPixelType<float>(), inputImage->GetDimension(), inputImage->GetDimensions());
   outputImage->SetSpacing(inputImage->GetGeometry()->GetSpacing());
-  outputImage->SetImportVolume(outputData, 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory);
+  outputImage->SetImportVolume(outputData, 0, 0, mitk::Image::ImportMemoryManagementType::RtlCopyMemory);
+  delete[] outputData;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
index 5ab767a9bd..7f04518e91 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
@@ -1,111 +1,112 @@
 /*===================================================================
 mitkCropImageFilter
 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 "mitkCropImageFilter.h"
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
 mitk::CropImageFilter::CropImageFilter() :
   m_XPixelsCropEnd(0),
   m_YPixelsCropEnd(0),
   m_ZPixelsCropEnd(0),
   m_XPixelsCropStart(0),
   m_YPixelsCropStart(0),
   m_ZPixelsCropStart(0)
 {
   MITK_INFO << "Instantiating CropImageFilter...";
   SetNumberOfIndexedInputs(1);
   SetNumberOfIndexedOutputs(1);
   MITK_INFO << "Instantiating CropImageFilter...[Done]";
 }
 
 mitk::CropImageFilter::~CropImageFilter()
 {
   MITK_INFO << "Destructed CastToFloatImageFilter.";
 }
 
 void mitk::CropImageFilter::SanityCheckPreconditions()
 {
   mitk::Image::Pointer inputImage = GetInput();
 
   std::string type = inputImage->GetPixelType().GetTypeAsString();
   if (!(type == "scalar (float)" || type == " (float)"))
   {
+    MITK_ERROR << "This filter can currently only handle float type images.";
     mitkThrow() << "This filter can currently only handle float type images.";
   }
 
   if (m_XPixelsCropStart + m_XPixelsCropEnd >= inputImage->GetDimension(0))
     mitkThrow() << "X Crop area too large for selected input image";
   if (m_YPixelsCropStart + m_YPixelsCropEnd >= inputImage->GetDimension(1))
     mitkThrow() << "Y Crop area too large for selected input image";
   if (inputImage->GetDimension() == 3)
   {
     if (m_ZPixelsCropStart + m_ZPixelsCropEnd >= inputImage->GetDimension(2))
     {
       mitkThrow() << "Z Crop area too large for selected input image";
     }
   }
   else
   {
     if (m_ZPixelsCropStart + m_ZPixelsCropEnd > 0)
     {
       mitkThrow() << "Z Crop area too large for selected input image";
     }
   }
 }
 
 void mitk::CropImageFilter::GenerateData()
 {
   mitk::Image::Pointer inputImage = GetInput();
   mitk::Image::Pointer outputImage = GetOutput();
 
   SanityCheckPreconditions();
   unsigned int* outputDim;
   unsigned int* inputDim = inputImage->GetDimensions();
 
   if (inputImage->GetDimension() == 2)
     outputDim = new unsigned int[2]{ inputImage->GetDimension(0) - m_XPixelsCropStart - m_XPixelsCropEnd,
     inputImage->GetDimension(1) - m_YPixelsCropStart - m_YPixelsCropEnd };
   else
     outputDim = new unsigned int[3]{ inputImage->GetDimension(0) - m_XPixelsCropStart - m_XPixelsCropEnd,
     inputImage->GetDimension(1) - m_YPixelsCropStart - m_YPixelsCropEnd,
     inputImage->GetDimension(2) - m_ZPixelsCropStart - m_ZPixelsCropEnd };
 
   outputImage->Initialize(mitk::MakeScalarPixelType<float>(), inputImage->GetDimension(), outputDim);
   outputImage->SetSpacing(inputImage->GetGeometry()->GetSpacing());
 
   ImageReadAccessor accR(inputImage);
   const float* inputData = (const float*)(accR.GetData());
 
   ImageWriteAccessor accW(outputImage);
   float* outputData = (float*)(accW.GetData());
 
   unsigned int zLength = inputImage->GetDimension() == 3 ? outputDim[2] : 0;
 
   for (unsigned int sl = 0; sl < zLength; ++sl)
   {
     for (unsigned int l = 0; l < outputDim[0]; ++l)
     {
       for (unsigned int s = 0; s < outputDim[1]; ++s)
       {
         outputData[l + s*outputDim[0] + sl*outputDim[0] * outputDim[1]] =
           inputData[(l + m_XPixelsCropStart) + (s + m_YPixelsCropStart)*inputDim[0] +
           (sl + m_ZPixelsCropStart)*inputDim[0] * inputDim[1]];
       }
     }
   }
   delete[] outputDim;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp b/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
index 76ae7a34b5..f805227198 100644
--- a/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
@@ -1,537 +1,548 @@
 /*===================================================================
 mitkPhotoacousticBeamformingFilter
 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 "mitkProperties.h"
 #include "mitkImageReadAccessor.h"
 #include <algorithm>
 #include <itkImageIOBase.h>
 #include <chrono>
 #include <thread>
 #include <itkImageIOBase.h>
 #include "mitkImageCast.h"
 #include "mitkBeamformingUtils.h"
 
 mitk::BeamformingUtils::BeamformingUtils()
 {
 }
 
 mitk::BeamformingUtils::~BeamformingUtils()
 {
 }
 
 float* mitk::BeamformingUtils::VonHannFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = (1 - cos(2 * itk::Math::pi * n / (samples - 1))) / 2;
   }
 
   return ApodWindow;
 }
 
 float* mitk::BeamformingUtils::HammFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = 0.54 - 0.46*cos(2 * itk::Math::pi*n / (samples - 1));
   }
 
   return ApodWindow;
 }
 
 float* mitk::BeamformingUtils::BoxFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = 1;
   }
 
   return ApodWindow;
 }
 
 void mitk::BeamformingUtils::DASQuadraticLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample = 0;
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() * config->GetSpeedOfSound() /
     config->GetPitchInMeters() * inputL / config->GetTransducerElements();
   float apod_mult = 1;
 
   short usedLines = (maxLine - minLine);
 
   //quadratic delay
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     delayMultiplicator = pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
       (config->GetPitchInMeters()*config->GetTransducerElements()) / inputL), 2) / s_i / 2;
 
     for (short l_s = minLine; l_s < maxLine; ++l_s)
     {
       AddSample = delayMultiplicator * pow((l_s - l_i), 2) + s_i + (1 - config->GetIsPhotoacousticImage())*s_i;
       if (AddSample < inputS && AddSample >= 0)
         output[sample*(short)outputL + line] += input[l_s + AddSample*(short)inputL] *
         apodisation[(short)((l_s - minLine)*apod_mult)];
       else
         --usedLines;
     }
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / usedLines;
   }
 }
 
 void mitk::BeamformingUtils::DASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
+
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample = 0;
   short maxLine = 0;
   short minLine = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() *
     config->GetSpeedOfSound() / config->GetPitchInMeters() * inputL / (float)config->GetTransducerElements();
   float apod_mult = 1;
 
   short usedLines = (maxLine - minLine);
 
   //exact delay
 
   l_i = (float)line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     for (short l_s = minLine; l_s < maxLine; ++l_s)
     {
       AddSample = (int)sqrt(
         pow(s_i, 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
         (((float)l_s - l_i)*config->GetPitchInMeters()*(float)config->GetTransducerElements()) / inputL), 2)
       ) + (1 - config->GetIsPhotoacousticImage())*s_i;
       if (AddSample < inputS && AddSample >= 0)
         output[sample*(short)outputL + line] += input[l_s + AddSample*(short)inputL] *
         apodisation[(short)((l_s - minLine)*apod_mult)];
       else
         --usedLines;
     }
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / usedLines;
   }
 }
 
 void mitk::BeamformingUtils::DMASQuadraticLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
+
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() *
     config->GetSpeedOfSound() / config->GetPitchInMeters() * inputL / (float)config->GetTransducerElements();
   float apod_mult = 1;
 
   float mult = 0;
   short usedLines = (maxLine - minLine);
 
   //quadratic delay
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     delayMultiplicator = pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
       (config->GetPitchInMeters()*config->GetTransducerElements()) / inputL), 2) / s_i / 2;
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)(delayMultiplicator * pow((minLine + l_s - l_i), 2) + s_i) +
         (1 - config->GetIsPhotoacousticImage())*s_i;
     }
 
     float s_1 = 0;
     float s_2 = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       if (AddSample[l_s1 - minLine] < inputS && AddSample[l_s1 - minLine] >= 0)
       {
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           if (AddSample[l_s2 - minLine] < inputS && AddSample[l_s2 - minLine] >= 0)
           {
             s_2 = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL];
             s_1 = input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL];
 
             mult = s_2 * apodisation[(int)((l_s2 - minLine)*apod_mult)] * s_1 * apodisation[(int)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(fabs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / (float)(pow(usedLines, 2) - (usedLines - 1));
 
     delete[] AddSample;
   }
 }
 
 void mitk::BeamformingUtils::DMASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
+
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short maxLine = 0;
   short minLine = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() *
     config->GetSpeedOfSound() / config->GetPitchInMeters() * inputL / (float)config->GetTransducerElements();
   float apod_mult = 1;
 
   float mult = 0;
 
   short usedLines = (maxLine - minLine);
 
   //exact delay
 
   l_i = (float)line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)sqrt(
         pow(s_i, 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
         (((float)minLine + (float)l_s - l_i)*config->GetPitchInMeters()*(float)config->GetTransducerElements()) / inputL), 2)
       ) + (1 - config->GetIsPhotoacousticImage())*s_i;
     }
 
     float s_1 = 0;
     float s_2 = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       if (AddSample[l_s1 - minLine] < inputS && AddSample[l_s1 - minLine] >= 0)
       {
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           if (AddSample[l_s2 - minLine] < inputS && AddSample[l_s2 - minLine] >= 0)
           {
             s_2 = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL];
             s_1 = input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL];
 
             mult = s_2 * apodisation[(int)((l_s2 - minLine)*apod_mult)] * s_1 * apodisation[(int)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(fabs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / (float)(pow(usedLines, 2) - (usedLines - 1));
 
     delete[] AddSample;
   }
 }
 
 void mitk::BeamformingUtils::sDMASQuadraticLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
+
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() * config->GetSpeedOfSound() /
     config->GetPitchInMeters() * inputL / (float)config->GetTransducerElements();
   float apod_mult = 1;
 
   float mult = 0;
   short usedLines = (maxLine - minLine);
 
   //quadratic delay
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     delayMultiplicator = pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
       (config->GetPitchInMeters()*config->GetTransducerElements()) / inputL), 2) / s_i / 2;
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)(delayMultiplicator * pow((minLine + l_s - l_i), 2) + s_i) +
         (1 - config->GetIsPhotoacousticImage())*s_i;
     }
 
     float s_1 = 0;
     float s_2 = 0;
     float sign = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       if (AddSample[l_s1 - minLine] < inputS && AddSample[l_s1 - minLine] >= 0)
       {
         s_1 = input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL];
         sign += s_1;
 
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           if (AddSample[l_s2 - minLine] < inputS && AddSample[l_s2 - minLine] >= 0)
           {
             s_2 = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL];
 
             mult = s_2 * apodisation[(int)((l_s2 - minLine)*apod_mult)] * s_1 * apodisation[(int)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(fabs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / (float)(pow(usedLines, 2) - (usedLines - 1)) * ((sign > 0) - (sign < 0));
 
     delete[] AddSample;
   }
 }
 
 void mitk::BeamformingUtils::sDMASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
-  const short& line, float* apodisation, const short& apodArraySize,
-  const mitk::BeamformingSettings::Pointer config)
+  const short& line, const mitk::BeamformingSettings::Pointer config)
 {
+  const float* apodisation = config->GetApodizationFunction();
+  const short apodArraySize = config->GetApodizationArraySize();
+
   float& inputS = inputDim[1];
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short maxLine = 0;
   short minLine = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(config->GetAngle() / 360 * 2 * itk::Math::pi);
   float part_multiplicator = tan_phi * config->GetTimeSpacing() * config->GetSpeedOfSound() /
     config->GetPitchInMeters() * inputL / (float)config->GetTransducerElements();
   float apod_mult = 1;
 
   float mult = 0;
 
   short usedLines = (maxLine - minLine);
 
   //exact delay
 
   l_i = (float)line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = (float)apodArraySize / (float)usedLines;
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)sqrt(
         pow(s_i, 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound()) *
         (((float)minLine + (float)l_s - l_i)*config->GetPitchInMeters()*(float)config->GetTransducerElements()) / inputL), 2)
       ) + (1 - config->GetIsPhotoacousticImage())*s_i;
     }
 
     float s_1 = 0;
     float s_2 = 0;
     float sign = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       if (AddSample[l_s1 - minLine] < inputS && AddSample[l_s1 - minLine] >= 0)
       {
         s_1 = input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL];
         sign += s_1;
 
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           if (AddSample[l_s2 - minLine] < inputS && AddSample[l_s2 - minLine] >= 0)
           {
             s_2 = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL];
 
             mult = s_2 * apodisation[(int)((l_s2 - minLine)*apod_mult)] * s_1 * apodisation[(int)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(fabs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = output[sample*(short)outputL + line] / (float)(pow(usedLines, 2) - (usedLines - 1)) * ((sign > 0) - (sign < 0));
 
     delete[] AddSample;
   }
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
index e519762011..ffa3db3902 100644
--- a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
@@ -1,442 +1,441 @@
 /*===================================================================
 
 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 "mitkPhotoacousticFilterService.h"
 #include "../ITKFilter/ITKUltrasound/itkBModeImageFilter.h"
 #include "../ITKFilter/itkPhotoacousticBModeImageFilter.h"
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkBeamformingFilter.h"
 #include <chrono>
 #include <mitkIOUtil.h>
 #include <mitkCropImageFilter.h>
 #include "./OpenCLFilter/mitkPhotoacousticBModeFilter.h"
 #include "mitkConvert2Dto3DImageFilter.h"
 #include <mitkCastToFloatImageFilter.h>
 
 // itk dependencies
 #include "itkImage.h"
 #include "itkResampleImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkCropImageFilter.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkIntensityWindowingImageFilter.h"
 #include <itkIndex.h>
 #include "itkMultiplyImageFilter.h"
 #include "itkBSplineInterpolateImageFunction.h"
 #include <mitkImageToItk.h>
 
 // needed itk image filters
 #include "mitkITKImageImport.h"
 #include "itkFFTShiftImageFilter.h"
 #include "itkMultiplyImageFilter.h"
 #include "itkComplexToModulusImageFilter.h"
 #include <itkAddImageFilter.h>
 #include "../ITKFilter/ITKUltrasound/itkFFT1DComplexConjugateToRealImageFilter.h"
 #include "../ITKFilter/ITKUltrasound/itkFFT1DRealToComplexConjugateImageFilter.h"
 
 mitk::PhotoacousticFilterService::PhotoacousticFilterService()
 {
   MITK_INFO << "[PhotoacousticFilterService] created filter service";
 }
 
 mitk::PhotoacousticFilterService::~PhotoacousticFilterService()
 {
   MITK_INFO << "[PhotoacousticFilterService] destructed filter service";
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyBmodeFilter(mitk::Image::Pointer inputImage, BModeMethod method, bool UseGPU, bool UseLogFilter, float resampleSpacing)
 {
   // the image needs to be of floating point type for the envelope filter to work; the casting is done automatically by the CastToItkImage
   typedef itk::Image< float, 3 > itkFloatImageType;
   typedef itk::IdentityTransform<double, 3> TransformType;
 
   if (method == BModeMethod::Abs)
   {
     mitk::Image::Pointer input;
     mitk::Image::Pointer out;
     if (inputImage->GetPixelType().GetTypeAsString() == "scalar (float)" || inputImage->GetPixelType().GetTypeAsString() == " (float)")
       input = inputImage;
     else
       input = ApplyCropping(inputImage, 0, 0, 0, 0, 0, 0);
 
     if (!UseGPU)
     {
       PhotoacousticBModeFilter::Pointer filter = PhotoacousticBModeFilter::New();
       filter->SetParameters(UseLogFilter);
       filter->SetInput(input);
       filter->Update();
 
       out = filter->GetOutput();
 
       if (resampleSpacing == 0)
         return out;
     }
 #ifdef PHOTOACOUSTICS_USE_GPU
     else
     {
       PhotoacousticOCLBModeFilter::Pointer filter = PhotoacousticOCLBModeFilter::New();
       filter->SetParameters(UseLogFilter);
       filter->SetInput(input);
       filter->Update();
 
       out = filter->GetOutput();
 
       if (resampleSpacing == 0)
         return out;
     }
 #endif
 
     typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
     ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
 
     itkFloatImageType::Pointer itkImage;
     mitk::CastToItkImage(out, itkImage);
     itkFloatImageType::SpacingType outputSpacing;
     itkFloatImageType::SizeType inputSize = itkImage->GetLargestPossibleRegion().GetSize();
     itkFloatImageType::SizeType outputSize = inputSize;
 
     outputSpacing[0] = itkImage->GetSpacing()[0];
     outputSpacing[1] = resampleSpacing;
     outputSpacing[2] = itkImage->GetSpacing()[2];
 
     outputSize[1] = inputSize[1] * itkImage->GetSpacing()[1] / outputSpacing[1];
 
     typedef itk::IdentityTransform<double, 3> TransformType;
     resampleImageFilter->SetInput(itkImage);
     resampleImageFilter->SetSize(outputSize);
     resampleImageFilter->SetOutputSpacing(outputSpacing);
     resampleImageFilter->SetTransform(TransformType::New());
 
     resampleImageFilter->UpdateLargestPossibleRegion();
     return mitk::GrabItkImageMemory(resampleImageFilter->GetOutput());
   }
   else if (method == BModeMethod::EnvelopeDetection)
   {
     typedef itk::BModeImageFilter < itkFloatImageType, itkFloatImageType > BModeFilterType;
     BModeFilterType::Pointer bModeFilter = BModeFilterType::New();  // LogFilter
 
     typedef itk::PhotoacousticBModeImageFilter < itkFloatImageType, itkFloatImageType > PhotoacousticBModeImageFilter;
     PhotoacousticBModeImageFilter::Pointer photoacousticBModeFilter = PhotoacousticBModeImageFilter::New(); // No LogFilter
 
     typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
     ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
 
     itkFloatImageType::Pointer itkImage;
 
     mitk::CastToItkImage(inputImage, itkImage);
 
     itkFloatImageType::Pointer bmode;
 
     if (UseLogFilter)
     {
       bModeFilter->SetInput(itkImage);
       bModeFilter->SetDirection(1);
       bmode = bModeFilter->GetOutput();
     }
     else
     {
       photoacousticBModeFilter->SetInput(itkImage);
       photoacousticBModeFilter->SetDirection(1);
       bmode = photoacousticBModeFilter->GetOutput();
     }
 
     // resampleSpacing == 0 means: do no resampling
     if (resampleSpacing == 0)
     {
       return mitk::GrabItkImageMemory(bmode);
     }
 
     itkFloatImageType::SpacingType outputSpacing;
     itkFloatImageType::SizeType inputSize = itkImage->GetLargestPossibleRegion().GetSize();
     itkFloatImageType::SizeType outputSize = inputSize;
 
     outputSpacing[0] = itkImage->GetSpacing()[0];
     outputSpacing[1] = resampleSpacing;
     outputSpacing[2] = itkImage->GetSpacing()[2];
 
     outputSize[1] = inputSize[1] * itkImage->GetSpacing()[1] / outputSpacing[1];
 
     resampleImageFilter->SetInput(bmode);
     resampleImageFilter->SetSize(outputSize);
     resampleImageFilter->SetOutputSpacing(outputSpacing);
     resampleImageFilter->SetTransform(TransformType::New());
 
     resampleImageFilter->UpdateLargestPossibleRegion();
     return mitk::GrabItkImageMemory(resampleImageFilter->GetOutput());
   }
   return nullptr;
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyResampling(mitk::Image::Pointer inputImage, unsigned int outputSize[2])
 {
   typedef itk::Image< float, 3 > itkFloatImageType;
 
   typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
   ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
   typedef itk::LinearInterpolateImageFunction<itkFloatImageType, double> T_Interpolator;
   itkFloatImageType::Pointer itkImage;
 
   mitk::CastToItkImage(inputImage, itkImage);
 
   itkFloatImageType::SpacingType outputSpacingItk;
   itkFloatImageType::SizeType inputSizeItk = itkImage->GetLargestPossibleRegion().GetSize();
   itkFloatImageType::SizeType outputSizeItk = inputSizeItk;
 
   outputSizeItk[0] = outputSize[0];
   outputSizeItk[1] = outputSize[1];
   outputSizeItk[2] = inputSizeItk[2];
 
   outputSpacingItk[0] = itkImage->GetSpacing()[0] * (static_cast<double>(inputSizeItk[0]) / static_cast<double>(outputSizeItk[0]));
   outputSpacingItk[1] = itkImage->GetSpacing()[1] * (static_cast<double>(inputSizeItk[1]) / static_cast<double>(outputSizeItk[1]));
   outputSpacingItk[2] = itkImage->GetSpacing()[2];
 
   typedef itk::IdentityTransform<double, 3> TransformType;
   T_Interpolator::Pointer _pInterpolator = T_Interpolator::New();
   resampleImageFilter->SetInput(itkImage);
   resampleImageFilter->SetSize(outputSizeItk);
   resampleImageFilter->SetOutputSpacing(outputSpacingItk);
   resampleImageFilter->SetTransform(TransformType::New());
   resampleImageFilter->SetInterpolator(_pInterpolator);
 
   resampleImageFilter->UpdateLargestPossibleRegion();
   return mitk::GrabItkImageMemory(resampleImageFilter->GetOutput());
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyCropping(mitk::Image::Pointer inputImage,
   int above, int below,
   int right, int left,
   int zStart, int zEnd)
 {
   mitk::CropImageFilter::Pointer cropImageFilter = mitk::CropImageFilter::New();
   cropImageFilter->SetInput(inputImage);
   cropImageFilter->SetXPixelsCropStart(left);
   cropImageFilter->SetXPixelsCropEnd(right);
   cropImageFilter->SetYPixelsCropStart(above);
   cropImageFilter->SetYPixelsCropEnd(below);
   cropImageFilter->SetZPixelsCropStart(zStart);
   cropImageFilter->SetZPixelsCropEnd(zEnd);
   cropImageFilter->Update();
   return cropImageFilter->GetOutput();
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyBeamforming(mitk::Image::Pointer inputImage,
-  BeamformingSettings::Pointer config, std::string& message, std::function<void(int, std::string)> progressHandle)
+  BeamformingSettings::Pointer config, std::function<void(int, std::string)> progressHandle)
 {
   Image::Pointer processedImage = mitk::Image::New();
 
   if (inputImage->GetDimension() != 3)
   {
     mitk::Convert2Dto3DImageFilter::Pointer dimensionImageFilter = mitk::Convert2Dto3DImageFilter::New();
     dimensionImageFilter->SetInput(inputImage);
     dimensionImageFilter->Update();
     processedImage = dimensionImageFilter->GetOutput();
   }
-
-  config->GetInputDim()[0] = processedImage->GetDimension(0);
-  config->GetInputDim()[1] = processedImage->GetDimension(1);
-  config->GetInputDim()[2] = processedImage->GetDimension(2);
+  else
+  {
+    processedImage = inputImage;
+  }
 
   // perform the beamforming
   m_BeamformingFilter = mitk::BeamformingFilter::New(config);
   m_BeamformingFilter->SetInput(processedImage);
   m_BeamformingFilter->SetProgressHandle(progressHandle);
   m_BeamformingFilter->UpdateLargestPossibleRegion();
 
   processedImage = m_BeamformingFilter->GetOutput();
-  message = m_BeamformingFilter->GetMessageString();
 
   return processedImage;
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::BandpassFilter(mitk::Image::Pointer data, float recordTime,
   float BPHighPass, float BPLowPass,
   float alphaHighPass, float alphaLowPass)
 {
   bool powerOfTwo = false;
   int finalPower = 0;
   for (int i = 1; pow(2, i) <= data->GetDimension(1); ++i)
   {
     finalPower = i;
     if (pow(2, i) == data->GetDimension(1))
     {
       powerOfTwo = true;
     }
   }
   if (!powerOfTwo)
   {
     unsigned int dim[2] = { data->GetDimension(0), (unsigned int)pow(2,finalPower + 1) };
     data = ApplyResampling(data, dim);
   }
 
   MITK_INFO << data->GetDimension(0);
 
   // do a fourier transform, multiply with an appropriate window for the filter, and transform back
   typedef float PixelType;
   typedef itk::Image< PixelType, 3 > RealImageType;
   RealImageType::Pointer image;
 
   mitk::CastToItkImage(data, image);
 
   typedef itk::FFT1DRealToComplexConjugateImageFilter<RealImageType> ForwardFFTFilterType;
   typedef ForwardFFTFilterType::OutputImageType ComplexImageType;
   ForwardFFTFilterType::Pointer forwardFFTFilter = ForwardFFTFilterType::New();
   forwardFFTFilter->SetInput(image);
   forwardFFTFilter->SetDirection(1);
   try
   {
     forwardFFTFilter->UpdateOutputInformation();
   }
   catch (itk::ExceptionObject & error)
   {
     std::cerr << "Error: " << error << std::endl;
     MITK_WARN << "Bandpass could not be applied";
     return data;
   }
 
   float singleVoxel = 1 / (recordTime / data->GetDimension(1)) / 2 / 1000;
   float cutoffPixelHighPass = std::min(BPHighPass / singleVoxel, (float)data->GetDimension(1) / 2);
   float cutoffPixelLowPass = std::min(BPLowPass / singleVoxel, (float)data->GetDimension(1) / 2 - cutoffPixelHighPass);
 
   RealImageType::Pointer fftMultiplicator = BPFunction(data, cutoffPixelHighPass, cutoffPixelLowPass, alphaHighPass, alphaLowPass);
 
   typedef itk::MultiplyImageFilter< ComplexImageType,
     RealImageType,
     ComplexImageType >
     MultiplyFilterType;
   MultiplyFilterType::Pointer multiplyFilter = MultiplyFilterType::New();
   multiplyFilter->SetInput1(forwardFFTFilter->GetOutput());
   multiplyFilter->SetInput2(fftMultiplicator);
 
   /*itk::ComplexToModulusImageFilter<ComplexImageType, RealImageType>::Pointer toReal = itk::ComplexToModulusImageFilter<ComplexImageType, RealImageType>::New();
   toReal->SetInput(forwardFFTFilter->GetOutput());
   return GrabItkImageMemory(toReal->GetOutput());
   return GrabItkImageMemory(fftMultiplicator);   *///DEBUG
 
   typedef itk::FFT1DComplexConjugateToRealImageFilter< ComplexImageType, RealImageType > InverseFilterType;
   InverseFilterType::Pointer inverseFFTFilter = InverseFilterType::New();
   inverseFFTFilter->SetInput(multiplyFilter->GetOutput());
   inverseFFTFilter->SetDirection(1);
 
   return GrabItkImageMemory(inverseFFTFilter->GetOutput());
 }
 
 itk::Image<float, 3U>::Pointer mitk::PhotoacousticFilterService::BPFunction(mitk::Image::Pointer reference,
   int cutoffFrequencyPixelHighPass,
   int cutoffFrequencyPixelLowPass,
   float alphaHighPass, float alphaLowPass)
 {
   float* imageData = new float[reference->GetDimension(0)*reference->GetDimension(1)];
 
   float width = reference->GetDimension(1) / 2.0 - (float)cutoffFrequencyPixelHighPass - (float)cutoffFrequencyPixelLowPass;
   float center = (float)cutoffFrequencyPixelHighPass / 2.0 + width / 2.0;
 
   for (unsigned int n = 0; n < reference->GetDimension(1); ++n)
   {
     imageData[reference->GetDimension(0)*n] = 0;
   }
   for (int n = 0; n < width; ++n)
   {
     imageData[reference->GetDimension(0)*n] = 1;
     if (n <= (alphaHighPass*(width - 1)) / 2.0)
     {
       if (alphaHighPass > 0.00001)
       {
         imageData[reference->GetDimension(0)*(int)(n + center - (width / 2))] =
           (1 + cos(itk::Math::pi*(2 * n / (alphaHighPass*(width - 1)) - 1))) / 2;
       }
       else
       {
         imageData[reference->GetDimension(0)*(int)(n + center - (width / 2))] = 1;
       }
     }
     else if (n >= (width - 1)*(1 - alphaLowPass / 2)) //???
     {
       if (alphaLowPass > 0.00001)
       {
         imageData[reference->GetDimension(0)*(int)(n + center - (width / 2))] =
           (1 + cos(itk::Math::pi*(2 * n / (alphaLowPass*(width - 1)) + 1 - 2 / alphaLowPass))) / 2;
       }
       else
       {
         imageData[reference->GetDimension(0)*(int)(n + center - (width / 2))] = 1;
       }
     }
     //MITK_INFO << "n:" << n << " is " << imageData[reference->GetDimension(0)*(int)(n + center - (width / 2))];
   }
   MITK_INFO << "width: " << width << ", center: " << center << ", alphaHighPass: " << alphaHighPass << ", alphaLowPass: " << alphaLowPass;
 
   // mirror the first half of the image
   for (unsigned int n = reference->GetDimension(1) / 2; n < reference->GetDimension(1); ++n)
   {
     imageData[reference->GetDimension(0)*n] = imageData[(reference->GetDimension(1) - (n + 1)) * reference->GetDimension(0)];
   }
 
   // copy and paste to all lines
   for (unsigned int line = 1; line < reference->GetDimension(0); ++line)
   {
     for (unsigned int sample = 0; sample < reference->GetDimension(1); ++sample)
     {
       imageData[reference->GetDimension(0)*sample + line] = imageData[reference->GetDimension(0)*sample];
     }
   }
 
   typedef itk::Image< float, 3U >  ImageType;
   ImageType::RegionType region;
   ImageType::IndexType start;
   start.Fill(0);
 
   region.SetIndex(start);
 
   ImageType::SizeType size;
   size[0] = reference->GetDimension(0);
   size[1] = reference->GetDimension(1);
   size[2] = reference->GetDimension(2);
 
   region.SetSize(size);
 
   ImageType::SpacingType SpacingItk;
   SpacingItk[0] = reference->GetGeometry()->GetSpacing()[0];
   SpacingItk[1] = reference->GetGeometry()->GetSpacing()[1];
   SpacingItk[2] = reference->GetGeometry()->GetSpacing()[2];
 
   ImageType::Pointer image = ImageType::New();
   image->SetRegions(region);
   image->Allocate();
   image->FillBuffer(itk::NumericTraits<float>::Zero);
   image->SetSpacing(SpacingItk);
 
   ImageType::IndexType pixelIndex;
 
   for (unsigned int slice = 0; slice < reference->GetDimension(2); ++slice)
   {
     for (unsigned int line = 0; line < reference->GetDimension(0); ++line)
     {
       for (unsigned int sample = 0; sample < reference->GetDimension(1); ++sample)
       {
         pixelIndex[0] = line;
         pixelIndex[1] = sample;
         pixelIndex[2] = slice;
 
         image->SetPixel(pixelIndex, imageData[line + sample*reference->GetDimension(0)]);
       }
     }
   }
 
   delete[] imageData;
 
   return image;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
index 139492343d..6bf86cfb2f 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
@@ -1,95 +1,111 @@
 /*===================================================================
 
 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 <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <mitkPhotoacousticFilterService.h>
 #include <mitkImage.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkBeamformingSettings.h>
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResourceStream.h>
 
 #include <random>
 #include <chrono>
 
 class mitkPAFilterServiceTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPAFilterServiceTestSuite);
   MITK_TEST(testRunning);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::PhotoacousticFilterService::Pointer m_PhotoacousticFilterService;
 
 public:
 
   void setUp() override
   {
     m_PhotoacousticFilterService = mitk::PhotoacousticFilterService::New();
   }
 
-  mitk::BeamformingSettings::Pointer CreateBeamformingSettings()
+  mitk::BeamformingSettings::Pointer CreateEmptyBeamformingSettings()
+  {
+    mitk::BeamformingSettings::Pointer config = mitk::BeamformingSettings::New();
+    return config;
+  }
+
+  mitk::BeamformingSettings::Pointer CreateFunctionalBeamformingSettings()
   {
     mitk::BeamformingSettings::Pointer config = mitk::BeamformingSettings::New();
     return config;
   }
 
   void testRunning()
   {
     int xDim = 3;
     int yDim = 3;
     int length = yDim * xDim;
-    int* testArray = new int[length];
+    float* testArray = new float[length];
     for (int i = 0; i < length; ++i)
     {
       testArray[i] = 0;
     }
+
     unsigned int NUMBER_OF_SPATIAL_DIMENSIONS = 2;
-    auto* dimensions = new unsigned int[NUMBER_OF_SPATIAL_DIMENSIONS];
+    unsigned int* dimensions = new unsigned int[NUMBER_OF_SPATIAL_DIMENSIONS];
     dimensions[0] = yDim;
     dimensions[1] = xDim;
-    mitk::PixelType pixelType = mitk::MakeScalarPixelType<int>();
+    mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
     mitk::Image::Pointer testImage = mitk::Image::New();
     testImage->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);
-    testImage->SetImportSlice(testArray, 0, 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory);
-    std::string message = "Es ist egal. Das taucht nicht auf!";
-    mitk::BeamformingSettings::Pointer config = CreateBeamformingSettings();
-    auto output = m_PhotoacousticFilterService->ApplyBeamforming(testImage, config, message);
+    testImage->SetImportSlice(testArray, 0, 0, 0, mitk::Image::ImportMemoryManagementType::RtlCopyMemory);
+    delete[] testArray;
+
+    mitk::ImageReadAccessor readAccessInput(testImage);
+    const float* inputArray = (const float*)readAccessInput.GetData();
+
+    for (int i = 0; i < length; ++i)
+    {
+      CPPUNIT_ASSERT_MESSAGE(std::string("Input array already not correct: " + std::to_string(inputArray[i])), abs(inputArray[i]) < 1e-5f);
+    }
+
+    mitk::BeamformingSettings::Pointer config = CreateEmptyBeamformingSettings();
+    auto output = m_PhotoacousticFilterService->ApplyBeamforming(testImage, config);
 
-    mitk::ImageReadAccessor readAccess(output, output->GetVolumeData());
-    const int* outputArray = (const int*)readAccess.GetData();
+    mitk::ImageReadAccessor readAccess(output);
+    const float* outputArray = (const float*)readAccess.GetData();
 
     for (int i = 0; i < length; ++i)
     {
-      CPPUNIT_ASSERT(outputArray[i] == 0);
+      CPPUNIT_ASSERT_MESSAGE(std::string("Ouput array not correct: " + std::to_string(abs(outputArray[i]))), abs(outputArray[i]) < 1e-5f);
     }
   }
 
   void tearDown() override
   {
     m_PhotoacousticFilterService = nullptr;
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPAFilterService)
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
index b5827dcdab..10a65f5d17 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
@@ -1,1160 +1,1161 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "PAImageProcessing.h"
 
 // Qt
 #include <QMessageBox>
 #include <QApplication>
 #include <QMetaType>
 #include <QFileDialog>
 
 //mitk image
 #include <mitkImage.h>
 #include "mitkPhotoacousticFilterService.h"
+#include "mitkCastToFloatImageFilter.h"
 #include "mitkBeamformingFilter.h"
 
 //other
 #include <thread>
 #include <functional>
 #include <mitkIOUtil.h>
 
 const std::string PAImageProcessing::VIEW_ID = "org.mitk.views.paimageprocessing";
 
 PAImageProcessing::PAImageProcessing() : m_ResampleSpacing(0), m_UseLogfilter(false), m_FilterBank(mitk::PhotoacousticFilterService::New())
 {
   qRegisterMetaType<mitk::Image::Pointer>();
   qRegisterMetaType<std::string>();
 }
 
 void PAImageProcessing::SetFocus()
 {
   m_Controls.buttonApplyBModeFilter->setFocus();
 }
 
 void PAImageProcessing::CreateQtPartControl(QWidget *parent)
 {
   BFconfig = mitk::BeamformingSettings::New();
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.buttonApplyBModeFilter, SIGNAL(clicked()), this, SLOT(StartBmodeThread()));
   connect(m_Controls.DoResampling, SIGNAL(clicked()), this, SLOT(UseResampling()));
   connect(m_Controls.Logfilter, SIGNAL(clicked()), this, SLOT(UseLogfilter()));
   connect(m_Controls.ResamplingValue, SIGNAL(valueChanged(double)), this, SLOT(SetResampling()));
   connect(m_Controls.buttonApplyBeamforming, SIGNAL(clicked()), this, SLOT(StartBeamformingThread()));
   connect(m_Controls.buttonApplyCropFilter, SIGNAL(clicked()), this, SLOT(StartCropThread()));
   connect(m_Controls.buttonApplyBandpass, SIGNAL(clicked()), this, SLOT(StartBandpassThread()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UseImageSpacing()));
   connect(m_Controls.ScanDepth, SIGNAL(valueChanged(double)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.SpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.SpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(ChangedSOSBeamforming()));
   connect(m_Controls.BPSpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(ChangedSOSBandpass()));
   connect(m_Controls.Samples, SIGNAL(valueChanged(int)), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UpdateImageInfo()));
   connect(m_Controls.boundLow, SIGNAL(valueChanged(int)), this, SLOT(LowerSliceBoundChanged()));
   connect(m_Controls.boundHigh, SIGNAL(valueChanged(int)), this, SLOT(UpperSliceBoundChanged()));
   connect(m_Controls.Partial, SIGNAL(clicked()), this, SLOT(SliceBoundsEnabled()));
   connect(m_Controls.BatchProcessing, SIGNAL(clicked()), this, SLOT(BatchProcessing()));
   connect(m_Controls.StepBeamforming, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepCropping, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepBandpass, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
   connect(m_Controls.StepBMode, SIGNAL(clicked()), this, SLOT(UpdateSaveBoxes()));
 
   UpdateSaveBoxes();
   m_Controls.DoResampling->setChecked(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.progressBar->setMinimum(0);
   m_Controls.progressBar->setMaximum(100);
   m_Controls.progressBar->setVisible(false);
   m_Controls.UseImageSpacing->setToolTip("Image spacing of y-Axis must be in us, x-Axis in mm.");
   m_Controls.UseImageSpacing->setToolTipDuration(5000);
   m_Controls.ProgressInfo->setVisible(false);
   m_Controls.UseBP->hide();
   m_Controls.UseGPUBmode->hide();
 
 #ifndef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(false);
   m_Controls.UseGPUBf->setChecked(false);
   m_Controls.UseGPUBmode->setEnabled(false);
   m_Controls.UseGPUBmode->setChecked(false);
 #endif
 
   UseImageSpacing();
 }
 
 void PAImageProcessing::ChangedSOSBandpass()
 {
   m_Controls.SpeedOfSound->setValue(m_Controls.BPSpeedOfSound->value());
 }
 
 void PAImageProcessing::ChangedSOSBeamforming()
 {
   m_Controls.BPSpeedOfSound->setValue(m_Controls.SpeedOfSound->value());
 }
 
 std::vector<std::string> splitpath(
   const std::string& str
   , const std::set<char> delimiters)
 {
   std::vector<std::string> result;
 
   char const* pch = str.c_str();
   char const* start = pch;
   for (; *pch; ++pch)
   {
     if (delimiters.find(*pch) != delimiters.end())
     {
       if (start != pch)
       {
         std::string str(start, pch);
         result.push_back(str);
       }
       else
       {
         result.push_back("");
       }
       start = pch + 1;
     }
   }
   result.push_back(start);
 
   return result;
 }
 
 void PAImageProcessing::UpdateSaveBoxes()
 {
   if (m_Controls.StepBeamforming->isChecked())
     m_Controls.SaveBeamforming->setEnabled(true);
   else
     m_Controls.SaveBeamforming->setEnabled(false);
 
   if (m_Controls.StepCropping->isChecked())
     m_Controls.SaveCropping->setEnabled(true);
   else
     m_Controls.SaveCropping->setEnabled(false);
 
   if (m_Controls.StepBandpass->isChecked())
     m_Controls.SaveBandpass->setEnabled(true);
   else
     m_Controls.SaveBandpass->setEnabled(false);
 
   if (m_Controls.StepBMode->isChecked())
     m_Controls.SaveBMode->setEnabled(true);
   else
     m_Controls.SaveBMode->setEnabled(false);
 }
 
 void PAImageProcessing::BatchProcessing()
 {
   QFileDialog LoadDialog(nullptr, "Select Files to be processed");
   LoadDialog.setFileMode(QFileDialog::FileMode::ExistingFiles);
   LoadDialog.setNameFilter(tr("Images (*.nrrd)"));
   LoadDialog.setViewMode(QFileDialog::Detail);
 
   QStringList fileNames;
   if (LoadDialog.exec())
     fileNames = LoadDialog.selectedFiles();
 
   QString saveDir = QFileDialog::getExistingDirectory(nullptr, tr("Select Directory To Save To"),
     "",
     QFileDialog::ShowDirsOnly
     | QFileDialog::DontResolveSymlinks);
 
   DisableControls();
 
   std::set<char> delims{ '/' };
 
   bool doSteps[] = { m_Controls.StepBeamforming->isChecked(), m_Controls.StepCropping->isChecked() , m_Controls.StepBandpass->isChecked(), m_Controls.StepBMode->isChecked() };
   bool saveSteps[] = { m_Controls.SaveBeamforming->isChecked(), m_Controls.SaveCropping->isChecked() , m_Controls.SaveBandpass->isChecked(), m_Controls.SaveBMode->isChecked() };
 
   for (int fileNumber = 0; fileNumber < fileNames.size(); ++fileNumber)
   {
     m_Controls.progressBar->setValue(0);
     m_Controls.progressBar->setVisible(true);
     m_Controls.ProgressInfo->setVisible(true);
     m_Controls.ProgressInfo->setText("loading file");
 
     QString filename = fileNames.at(fileNumber);
     auto split = splitpath(filename.toStdString(), delims);
     std::string imageName = split.at(split.size() - 1);
 
     // remove ".nrrd"
     imageName = imageName.substr(0, imageName.size() - 5);
 
     mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(filename.toStdString().c_str());
 
     UpdateBFSettings(image);
     // Beamforming
     if (doSteps[0])
     {
       std::function<void(int, std::string)> progressHandle = [this](int progress, std::string progressInfo) {
         this->UpdateProgress(progress, progressInfo);
       };
       m_Controls.progressBar->setValue(100);
-      std::string errorMessage = "";
 
-      image = m_FilterBank->ApplyBeamforming(image, BFconfig, errorMessage, progressHandle);
+      image = m_FilterBank->ApplyBeamforming(image, BFconfig, progressHandle);
 
       if (saveSteps[0])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " beamformed" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
 
     // Cropping
     if (doSteps[1])
     {
       m_Controls.ProgressInfo->setText("cropping image");
 
       image = m_FilterBank->ApplyCropping(image, m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value(), 0, 0, 0, 0);
 
       if (saveSteps[1])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " cropped" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
 
     // Bandpass
     if (doSteps[2])
     {
       m_Controls.ProgressInfo->setText("applying bandpass");
       float recordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000 / m_Controls.BPSpeedOfSound->value();
       // add a safeguard so the program does not chrash when applying a Bandpass that reaches out of the bounds of the image
       float maxFrequency = 1 / (recordTime / image->GetDimension(1)) * image->GetDimension(1) / 2 / 2 / 1000;
       float BPHighPass = 1000000 * m_Controls.BPhigh->value(); // [Hz]
       float BPLowPass = maxFrequency - 1000000 * m_Controls.BPlow->value(); // [Hz]
 
       if (BPLowPass > maxFrequency && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too low, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPLowPass < 0 && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too high, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPHighPass > maxFrequency &&  m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass too high, disabled it.");
         Msgbox.exec();
 
         BPHighPass = 0;
       }
       if (BPHighPass > maxFrequency - BFconfig->GetBPLowPass())
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass higher than LowPass, disabled both.");
         Msgbox.exec();
 
         BPHighPass = 0;
         BPLowPass = 0;
       }
 
       image = m_FilterBank->BandpassFilter(image, recordTime, BPHighPass, BPLowPass,
         m_Controls.BPFalloffHigh->value(),
         m_Controls.BPFalloffLow->value());
 
       if (saveSteps[2])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " bandpassed" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
     // Bmode
     if (doSteps[3])
     {
       m_Controls.ProgressInfo->setText("applying bmode filter");
       bool useGPU = m_Controls.UseGPUBmode->isChecked();
 
       if (m_Controls.BModeMethod->currentText() == "Absolute Filter")
         image = m_FilterBank->ApplyBmodeFilter(image, mitk::PhotoacousticFilterService::BModeMethod::Abs, useGPU, m_UseLogfilter, m_ResampleSpacing);
       else if (m_Controls.BModeMethod->currentText() == "Envelope Detection")
         image = m_FilterBank->ApplyBmodeFilter(image, mitk::PhotoacousticFilterService::BModeMethod::EnvelopeDetection, useGPU, m_UseLogfilter, m_ResampleSpacing);
 
       if (saveSteps[3])
       {
         std::string saveFileName = saveDir.toStdString() + "/" + imageName + " bmode" + ".nrrd";
         mitk::IOUtil::Save(image, saveFileName);
       }
     }
     m_Controls.progressBar->setVisible(false);
   }
 
   EnableControls();
 }
 
 void PAImageProcessing::StartBeamformingThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing beamforming for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.progressBar->setValue(0);
       m_Controls.progressBar->setVisible(true);
       m_Controls.ProgressInfo->setVisible(true);
       m_Controls.ProgressInfo->setText("started");
       m_Controls.buttonApplyBeamforming->setText("working...");
       DisableControls();
 
       BeamformingThread *thread = new BeamformingThread();
       connect(thread, &BeamformingThread::result, this, &PAImageProcessing::HandleBeamformingResults);
       connect(thread, &BeamformingThread::updateProgress, this, &PAImageProcessing::UpdateProgress);
-      connect(thread, &BeamformingThread::message, this, &PAImageProcessing::PAMessageBox);
       connect(thread, &BeamformingThread::finished, thread, &QObject::deleteLater);
 
       thread->setConfig(BFconfig);
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Beamforming";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBeamformingResults(mitk::Image::Pointer image)
 {
   MITK_INFO << "Handle Beamforming results";
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
 
   newNodeName << m_OldNodeName << " ";
 
   if (BFconfig->GetAlgorithm() == mitk::BeamformingSettings::BeamformingAlgorithm::DAS)
     newNodeName << "DAS bf, ";
   else if (BFconfig->GetAlgorithm() == mitk::BeamformingSettings::BeamformingAlgorithm::DMAS)
     newNodeName << "DMAS bf, ";
 
   if (BFconfig->GetDelayCalculationMethod() == mitk::BeamformingSettings::DelayCalc::QuadApprox)
     newNodeName << "q. delay";
   if (BFconfig->GetDelayCalculationMethod() == mitk::BeamformingSettings::DelayCalc::Spherical)
     newNodeName << "s. delay";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   levelWindow.SetAuto(image, true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   // disable progress bar
   m_Controls.progressBar->setVisible(false);
   m_Controls.ProgressInfo->setVisible(false);
   m_Controls.buttonApplyBeamforming->setText("Apply Beamforming");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(image->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartBmodeThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing image processing for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyBModeFilter->setText("working...");
       DisableControls();
 
       BmodeThread *thread = new BmodeThread();
       connect(thread, &BmodeThread::result, this, &PAImageProcessing::HandleBmodeResults);
       connect(thread, &BmodeThread::finished, thread, &QObject::deleteLater);
 
       bool useGPU = m_Controls.UseGPUBmode->isChecked();
 
       if (m_Controls.BModeMethod->currentText() == "Absolute Filter")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticFilterService::BModeMethod::Abs, useGPU);
       else if (m_Controls.BModeMethod->currentText() == "Envelope Detection")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticFilterService::BModeMethod::EnvelopeDetection, useGPU);
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Image Processing";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBmodeResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "B-Mode";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   // disable progress bar
   m_Controls.progressBar->setVisible(false);
   m_Controls.buttonApplyBModeFilter->setText("Apply B-mode Filter");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartCropThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image cropping.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing image cropping for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyCropFilter->setText("working...");
       DisableControls();
 
       CropThread *thread = new CropThread();
       connect(thread, &CropThread::result, this, &PAImageProcessing::HandleCropResults);
       connect(thread, &CropThread::finished, thread, &QObject::deleteLater);
 
       thread->setConfig(m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value(), 0, image->GetDimension(2) - 1);
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Image Cropping";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleCropResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "Cropped";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   m_Controls.buttonApplyCropFilter->setText("Apply Crop Filter");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartBandpassThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image cropping.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing Bandpass filter on image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyBandpass->setText("working...");
       DisableControls();
 
       BandpassThread *thread = new BandpassThread();
       connect(thread, &BandpassThread::result, this, &PAImageProcessing::HandleBandpassResults);
       connect(thread, &BandpassThread::finished, thread, &QObject::deleteLater);
 
       float recordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000 / m_Controls.BPSpeedOfSound->value();
 
       // add a safeguard so the program does not chrash when applying a Bandpass that reaches out of the bounds of the image
       float maxFrequency = 1 / (recordTime / image->GetDimension(1)) * image->GetDimension(1) / 2 / 2 / 1000;
       float BPHighPass = 1000000 * m_Controls.BPhigh->value(); // [Hz]
       float BPLowPass = maxFrequency - 1000000 * m_Controls.BPlow->value(); // [Hz]
 
       if (BPLowPass > maxFrequency && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too low, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPLowPass < 0 && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too high, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPHighPass > maxFrequency &&  m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass too high, disabled it.");
         Msgbox.exec();
 
         BPHighPass = 0;
       }
       if (BPHighPass > maxFrequency - BFconfig->GetBPLowPass())
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass higher than LowPass, disabled both.");
         Msgbox.exec();
 
         BPHighPass = 0;
         BPLowPass = 0;
       }
 
       thread->setConfig(BPHighPass, BPLowPass, m_Controls.BPFalloffLow->value(), m_Controls.BPFalloffHigh->value(), recordTime);
       thread->setInputImage(image);
       thread->setFilterBank(m_FilterBank);
 
       MITK_INFO << "Started new thread for Bandpass filter";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBandpassResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "Bandpassed";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   m_Controls.buttonApplyBandpass->setText("Apply Bandpass");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::SliceBoundsEnabled()
 {
   if (!m_Controls.Partial->isChecked())
   {
     m_Controls.boundLow->setEnabled(false);
     m_Controls.boundHigh->setEnabled(false);
     return;
   }
   else
   {
     m_Controls.boundLow->setEnabled(true);
     m_Controls.boundHigh->setEnabled(true);
   }
 }
 
 void PAImageProcessing::UpperSliceBoundChanged()
 {
   if (m_Controls.boundLow->value() > m_Controls.boundHigh->value())
   {
     m_Controls.boundLow->setValue(m_Controls.boundHigh->value());
   }
 }
 
 void PAImageProcessing::LowerSliceBoundChanged()
 {
   if (m_Controls.boundLow->value() > m_Controls.boundHigh->value())
   {
     m_Controls.boundHigh->setValue(m_Controls.boundLow->value());
   }
 }
 
 void PAImageProcessing::UpdateProgress(int progress, std::string progressInfo)
 {
   if (progress < 100)
     m_Controls.progressBar->setValue(progress);
   else
     m_Controls.progressBar->setValue(100);
   m_Controls.ProgressInfo->setText(progressInfo.c_str());
   qApp->processEvents();
 }
 
 void PAImageProcessing::PAMessageBox(std::string message)
 {
   if (0 != message.compare("noMessage"))
   {
     QMessageBox msgBox;
     msgBox.setText(message.c_str());
     msgBox.exec();
   }
 }
 
 void PAImageProcessing::UpdateImageInfo()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
 
     if (image)
     {
       // beamforming configs
       if (m_Controls.UseImageSpacing->isChecked())
       {
         m_Controls.ElementCount->setValue(image->GetDimension(0));
         m_Controls.Pitch->setValue(image->GetGeometry()->GetSpacing()[0]);
       }
 
       m_Controls.boundLow->setMaximum(image->GetDimension(2) - 1);
       m_Controls.boundHigh->setMaximum(image->GetDimension(2) - 1);
 
       UpdateBFSettings(image);
 
       std::stringstream frequency;
       float maxFrequency = (1 / BFconfig->GetTimeSpacing()) * image->GetDimension(1) / 2 / 2 / 1000;
       frequency << maxFrequency / 1000000; //[MHz]
       frequency << "MHz";
 
       m_Controls.BPhigh->setMaximum(maxFrequency / 1000000);
       m_Controls.BPlow->setMaximum(maxFrequency / 1000000);
 
       frequency << " is the maximal allowed frequency for the selected image.";
       m_Controls.BPhigh->setToolTip(frequency.str().c_str());
       m_Controls.BPlow->setToolTip(frequency.str().c_str());
       m_Controls.BPhigh->setToolTipDuration(5000);
       m_Controls.BPlow->setToolTipDuration(5000);
     }
   }
 }
 
 void PAImageProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
   const QList<mitk::DataNode::Pointer>& nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
     {
       m_Controls.labelWarning->setVisible(false);
       m_Controls.buttonApplyBModeFilter->setEnabled(true);
       m_Controls.labelWarning2->setVisible(false);
       m_Controls.buttonApplyCropFilter->setEnabled(true);
       m_Controls.labelWarning3->setVisible(false);
       m_Controls.buttonApplyBandpass->setEnabled(true);
       m_Controls.labelWarning4->setVisible(false);
       m_Controls.buttonApplyBeamforming->setEnabled(true);
       UpdateImageInfo();
       return;
     }
   }
   m_Controls.labelWarning->setVisible(true);
   m_Controls.buttonApplyBModeFilter->setEnabled(false);
   m_Controls.labelWarning2->setVisible(true);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
   m_Controls.labelWarning3->setVisible(true);
   m_Controls.buttonApplyBandpass->setEnabled(false);
   m_Controls.labelWarning4->setVisible(true);
   m_Controls.buttonApplyBeamforming->setEnabled(false);
 }
 
 void PAImageProcessing::UseResampling()
 {
   if (m_Controls.DoResampling->isChecked())
   {
     m_Controls.ResamplingValue->setEnabled(true);
     m_ResampleSpacing = m_Controls.ResamplingValue->value();
   }
   else
   {
     m_Controls.ResamplingValue->setEnabled(false);
     m_ResampleSpacing = 0;
   }
 }
 
 void PAImageProcessing::UseLogfilter()
 {
   m_UseLogfilter = m_Controls.Logfilter->isChecked();
 }
 
 void PAImageProcessing::SetResampling()
 {
   m_ResampleSpacing = m_Controls.ResamplingValue->value();
 }
 
 void PAImageProcessing::UpdateBFSettings(mitk::Image::Pointer image)
 {
   if ("DAS" == m_Controls.BFAlgorithm->currentText())
     BFconfig->SetAlgorithm(mitk::BeamformingSettings::BeamformingAlgorithm::DAS);
   else if ("DMAS" == m_Controls.BFAlgorithm->currentText())
     BFconfig->SetAlgorithm(mitk::BeamformingSettings::BeamformingAlgorithm::DMAS);
   else if ("sDMAS" == m_Controls.BFAlgorithm->currentText())
     BFconfig->SetAlgorithm(mitk::BeamformingSettings::BeamformingAlgorithm::sDMAS);
 
   if ("Quad. Approx." == m_Controls.DelayCalculation->currentText())
   {
     BFconfig->SetDelayCalculationMethod(mitk::BeamformingSettings::DelayCalc::QuadApprox);
   }
   else if ("Spherical Wave" == m_Controls.DelayCalculation->currentText())
   {
     BFconfig->SetDelayCalculationMethod(mitk::BeamformingSettings::DelayCalc::Spherical);
   }
 
   if ("Von Hann" == m_Controls.Apodization->currentText())
   {
     BFconfig->SetApod(mitk::BeamformingSettings::Apodization::Hann);
   }
   else if ("Hamming" == m_Controls.Apodization->currentText())
   {
     BFconfig->SetApod(mitk::BeamformingSettings::Apodization::Hamm);
   }
   else if ("Box" == m_Controls.Apodization->currentText())
   {
     BFconfig->SetApod(mitk::BeamformingSettings::Apodization::Box);
   }
 
   BFconfig->SetPitchInMeters(m_Controls.Pitch->value() / 1000); // [m]
   BFconfig->SetSpeedOfSound(m_Controls.SpeedOfSound->value()); // [m/s]
   BFconfig->SetSamplesPerLine(m_Controls.Samples->value());
   BFconfig->SetReconstructionLines(m_Controls.Lines->value());
   BFconfig->SetTransducerElements(m_Controls.ElementCount->value());
   BFconfig->SetApodizationArraySize(m_Controls.Lines->value());
   BFconfig->SetAngle(m_Controls.Angle->value()); // [deg]
   BFconfig->SetUseBP(m_Controls.UseBP->isChecked());
   BFconfig->SetUseGPU(m_Controls.UseGPUBf->isChecked());
 
   if (m_Controls.UseImageSpacing->isChecked())
   {
     BFconfig->SetTimeSpacing(image->GetGeometry()->GetSpacing()[1] / 1000000);
     MITK_INFO << "Calculated Scan Depth of " << (image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000000) * BFconfig->GetSpeedOfSound() * 100 / 2 << "cm";
   }
   else
   {
     BFconfig->SetTimeSpacing((2 * m_Controls.ScanDepth->value() / 1000 / BFconfig->GetSpeedOfSound()) / image->GetDimension(1));
   }
 
   if ("US Image" == m_Controls.ImageType->currentText())
   {
     BFconfig->SetIsPhotoacousticImage(false);
   }
   else if ("PA Image" == m_Controls.ImageType->currentText())
   {
     BFconfig->SetIsPhotoacousticImage(true);
   }
 
   BFconfig->SetPartial(m_Controls.Partial->isChecked());
   BFconfig->GetCropBounds()[0] = m_Controls.boundLow->value();
   BFconfig->GetCropBounds()[1] = m_Controls.boundHigh->value();
 }
 
 void PAImageProcessing::EnableControls()
 {
   m_Controls.BatchProcessing->setEnabled(true);
   m_Controls.StepBeamforming->setEnabled(true);
   m_Controls.StepBandpass->setEnabled(true);
   m_Controls.StepCropping->setEnabled(true);
   m_Controls.StepBMode->setEnabled(true);
 
   UpdateSaveBoxes();
 
   m_Controls.DoResampling->setEnabled(true);
   UseResampling();
   m_Controls.Logfilter->setEnabled(true);
   m_Controls.BModeMethod->setEnabled(true);
   m_Controls.buttonApplyBModeFilter->setEnabled(true);
 
   m_Controls.CutoffAbove->setEnabled(true);
   m_Controls.CutoffBelow->setEnabled(true);
   m_Controls.buttonApplyCropFilter->setEnabled(true);
   m_Controls.BPSpeedOfSound->setEnabled(true);
   m_Controls.buttonApplyBandpass->setEnabled(true);
 
   m_Controls.Partial->setEnabled(true);
   m_Controls.boundHigh->setEnabled(true);
   m_Controls.boundLow->setEnabled(true);
   m_Controls.BFAlgorithm->setEnabled(true);
   m_Controls.DelayCalculation->setEnabled(true);
   m_Controls.ImageType->setEnabled(true);
   m_Controls.Apodization->setEnabled(true);
   m_Controls.UseBP->setEnabled(true);
 
 #ifdef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(true);
   m_Controls.UseGPUBmode->setEnabled(true);
 #endif
 
   m_Controls.BPhigh->setEnabled(true);
   m_Controls.BPlow->setEnabled(true);
   m_Controls.BPFalloffLow->setEnabled(true);
   m_Controls.BPFalloffHigh->setEnabled(true);
   m_Controls.UseImageSpacing->setEnabled(true);
   UseImageSpacing();
   m_Controls.Pitch->setEnabled(true);
   m_Controls.ElementCount->setEnabled(true);
   m_Controls.SpeedOfSound->setEnabled(true);
   m_Controls.Samples->setEnabled(true);
   m_Controls.Lines->setEnabled(true);
   m_Controls.Angle->setEnabled(true);
   m_Controls.buttonApplyBeamforming->setEnabled(true);
 }
 
 void PAImageProcessing::DisableControls()
 {
   m_Controls.BatchProcessing->setEnabled(false);
   m_Controls.StepBeamforming->setEnabled(false);
   m_Controls.StepBandpass->setEnabled(false);
   m_Controls.StepCropping->setEnabled(false);
   m_Controls.StepBMode->setEnabled(false);
   m_Controls.SaveBeamforming->setEnabled(false);
   m_Controls.SaveBandpass->setEnabled(false);
   m_Controls.SaveCropping->setEnabled(false);
   m_Controls.SaveBMode->setEnabled(false);
 
   m_Controls.DoResampling->setEnabled(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.Logfilter->setEnabled(false);
   m_Controls.BModeMethod->setEnabled(false);
   m_Controls.buttonApplyBModeFilter->setEnabled(false);
 
   m_Controls.CutoffAbove->setEnabled(false);
   m_Controls.CutoffBelow->setEnabled(false);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
   m_Controls.BPSpeedOfSound->setEnabled(false);
   m_Controls.buttonApplyBandpass->setEnabled(false);
 
   m_Controls.Partial->setEnabled(false);
   m_Controls.boundHigh->setEnabled(false);
   m_Controls.boundLow->setEnabled(false);
   m_Controls.BFAlgorithm->setEnabled(false);
   m_Controls.DelayCalculation->setEnabled(false);
   m_Controls.ImageType->setEnabled(false);
   m_Controls.Apodization->setEnabled(false);
   m_Controls.UseBP->setEnabled(false);
 
 #ifdef PHOTOACOUSTICS_USE_GPU
   m_Controls.UseGPUBf->setEnabled(false);
   m_Controls.UseGPUBmode->setEnabled(false);
 #endif
 
   m_Controls.BPhigh->setEnabled(false);
   m_Controls.BPlow->setEnabled(false);
   m_Controls.BPFalloffLow->setEnabled(false);
   m_Controls.BPFalloffHigh->setEnabled(false);
   m_Controls.UseImageSpacing->setEnabled(false);
   m_Controls.ScanDepth->setEnabled(false);
   m_Controls.Pitch->setEnabled(false);
   m_Controls.ElementCount->setEnabled(false);
   m_Controls.SpeedOfSound->setEnabled(false);
   m_Controls.Samples->setEnabled(false);
   m_Controls.Lines->setEnabled(false);
   m_Controls.Angle->setEnabled(false);
   m_Controls.buttonApplyBeamforming->setEnabled(false);
 }
 
 void PAImageProcessing::UseImageSpacing()
 {
   if (m_Controls.UseImageSpacing->isChecked())
   {
     m_Controls.ScanDepth->setDisabled(true);
   }
   else
   {
     m_Controls.ScanDepth->setEnabled(true);
   }
 }
 
 #include <mitkImageReadAccessor.h>
 
 void BeamformingThread::run()
 {
   mitk::Image::Pointer resultImage = mitk::Image::New();
   mitk::Image::Pointer resultImageBuffer;
-  std::string errorMessage = "";
   std::function<void(int, std::string)> progressHandle = [this](int progress, std::string progressInfo) {
     emit updateProgress(progress, progressInfo);
   };
-
-  resultImageBuffer = m_FilterBank->ApplyBeamforming(m_InputImage, m_BFconfig, errorMessage, progressHandle);
+  mitk::CastToFloatImageFilter::Pointer castToFloatImageFilter = mitk::CastToFloatImageFilter::New();
+  castToFloatImageFilter->SetInput(m_InputImage);
+  castToFloatImageFilter->Update();
+  m_InputImage = castToFloatImageFilter->GetOutput();
+  mitk::IOUtil::Save(m_InputImage, "G:/castedImage.nrrd");
+  resultImageBuffer = m_FilterBank->ApplyBeamforming(m_InputImage, m_BFconfig, progressHandle);
   mitk::ImageReadAccessor copy(resultImageBuffer);
 
   resultImage->Initialize(resultImageBuffer);
   resultImage->SetSpacing(resultImageBuffer->GetGeometry()->GetSpacing());
   resultImage->SetImportVolume(const_cast<void*>(copy.GetData()), 0, 0, mitk::Image::CopyMemory);
 
   emit result(resultImage);
-  emit message(errorMessage);
 }
 
 void BeamformingThread::setConfig(mitk::BeamformingSettings::Pointer BFconfig)
 {
   m_BFconfig = BFconfig;
 }
 
 void BeamformingThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BmodeThread::run()
 {
   mitk::Image::Pointer resultImage;
 
   resultImage = m_FilterBank->ApplyBmodeFilter(m_InputImage, m_Method, m_UseGPU, m_UseLogfilter, m_ResampleSpacing);
 
   emit result(resultImage);
 }
 
 void BmodeThread::setConfig(bool useLogfilter, double resampleSpacing, mitk::PhotoacousticFilterService::BModeMethod method, bool useGPU)
 {
   m_UseLogfilter = useLogfilter;
   m_ResampleSpacing = resampleSpacing;
   m_Method = method;
   m_UseGPU = useGPU;
 }
 
 void BmodeThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void CropThread::run()
 {
   mitk::Image::Pointer resultImage;
 
   resultImage = m_FilterBank->ApplyCropping(m_InputImage, m_CutAbove, m_CutBelow, 0, 0, 0, 0);
 
   emit result(resultImage);
 }
 
 void CropThread::setConfig(unsigned int CutAbove, unsigned int CutBelow, unsigned int CutSliceFirst, unsigned int CutSliceLast)
 {
   m_CutAbove = CutAbove;
   m_CutBelow = CutBelow;
   m_CutSliceLast = CutSliceLast;
   m_CutSliceFirst = CutSliceFirst;
 }
 
 void CropThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BandpassThread::run()
 {
   mitk::Image::Pointer resultImage;
 
   resultImage = m_FilterBank->BandpassFilter(m_InputImage, m_RecordTime, m_BPHighPass, m_BPLowPass, m_TukeyAlphaHighPass, m_TukeyAlphaLowPass);
   emit result(resultImage);
 }
 
 void BandpassThread::setConfig(float BPHighPass, float BPLowPass, float TukeyAlphaHighPass, float TukeyAlphaLowPass, float recordTime)
 {
   m_BPHighPass = BPHighPass;
   m_BPLowPass = BPLowPass;
   m_TukeyAlphaHighPass = TukeyAlphaHighPass;
   m_TukeyAlphaLowPass = TukeyAlphaLowPass;
   m_RecordTime = recordTime;
 }
 
 void BandpassThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }