diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl b/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
index 43927adc8a..731d4befc1 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
@@ -1,127 +1,125 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 __kernel void ckDAS(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global unsigned short* usedLines,
   __global unsigned short* delays,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   unsigned int Slices,
   unsigned int outputL,
   unsigned int outputS  // parameters
 )
 {
   // get thread identifier
   unsigned int globalPosX = get_global_id(0);
   unsigned int globalPosY = get_global_id(1);
   unsigned int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {	
     float l_i = (float)globalPosX / (float)outputL * (float)inputL;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
     
     float apod_mult = (float)apodArraySize / (float)curUsedLines;
     
     unsigned short Delay = 0;
     
     float output = 0;
     float mult = 0;
     
     for (short l_s = minLine; l_s < maxLine; ++l_s)
     {
       Delay = delays[globalPosY * (outputL / 2) + (int)(fabs(l_s - l_i)/(float)inputL * (float)outputL)];
       if (Delay < inputS && Delay >= 0) {
         output += apodArray[(int)((l_s - minLine)*apod_mult)] * dSource[(int)(globalPosZ * inputL * inputS + Delay * inputL + l_s)];
       }
       else
         --curUsedLines;
     }
     
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (float)curUsedLines;
   }
 }
 
 __kernel void ckDAS_g(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* elementHeights,
   __global float* elementPositions,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   int Slices,
   int outputL,
   int outputS,
-  float angle,
-  float probeRadius,
   float totalSamples_i,
   float horizontalExtent,
   float mult,
   char isPAImage,
   __global unsigned short* usedLines // parameters
 )
 {
   // get thread identifier
   int globalPosX = get_global_id(0);
   int globalPosY = get_global_id(1);
   int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {
     int AddSample = 0;
     float l_p = 0;
     float s_i = 0;
 
     float apod_mult = 1;
     
     float output = 0;
 
     l_p = (float)globalPosX / outputL * horizontalExtent;
     s_i = (float)globalPosY / outputS * totalSamples_i;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
 
     apod_mult = (float)apodArraySize / curUsedLines;
 
     for (int l_s = minLine; l_s < maxLine; ++l_s)
     {
       AddSample = (int)sqrt(
         pow(s_i-elementHeights[l_s]*mult, 2)
         +
         pow(mult * (l_p - elementPositions[l_s]), 2)
       ) + (1 - isPAImage)*s_i;
       if (AddSample < inputS && AddSample >= 0)
         output += dSource[l_s + AddSample*inputL] *
         apodArray[(int)((l_s - minLine)*apod_mult)];
       else
         --curUsedLines;
     }
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / curUsedLines;
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl b/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl
index dee635936e..741437aeed 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl
@@ -1,169 +1,167 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 __kernel void ckDMAS(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global unsigned short* usedLines,
   __global unsigned short* AddSamples,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   unsigned int Slices,
   unsigned int outputL,
   unsigned int outputS  // parameters
 )
 {
   // get thread identifier
   unsigned int globalPosX = get_global_id(0);
   unsigned int globalPosY = get_global_id(1);
   unsigned int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {	
     float l_i = (float)globalPosX / (float)outputL * (float)inputL;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
 
     float apod_mult = (float)apodArraySize / (float)curUsedLines;
 
     unsigned short Delay1 = 0;
     unsigned short Delay2 = 0;
 
     float output = 0;
     float mult = 0;
     
     float s_1 = 0;
     float s_2 = 0;
     float apod_1 = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
       Delay1 = AddSamples[globalPosY * (outputL / 2) + (int)(fabs(l_s1 - l_i)/(float)inputL * (float)outputL)];
       if (Delay1 < inputS && Delay1 >= 0) 
       {
         s_1 = dSource[(int)(globalPosZ * inputL * inputS + Delay1 * inputL + l_s1)];
         apod_1 = apodArray[(int)((l_s1 - minLine)*apod_mult)];
         
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           Delay2 = AddSamples[globalPosY * (outputL / 2) + (int)(fabs(l_s2 - l_i)/(float)inputL * (float)outputL)];
           if (Delay2 < inputS && Delay2 >= 0) 
           {
             s_2 = dSource[(int)(globalPosZ * inputL * inputS + Delay2 * inputL + l_s2)];
             
             mult = apodArray[(int)((l_s2 - minLine)*apod_mult)] * s_2 * apod_1 * s_1;
               
             output += sqrt(fabs(mult)) * sign(mult);
           }
         }
       }
       else
         --curUsedLines;
     }
 
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (float)(curUsedLines * curUsedLines - (curUsedLines - 1));
   }
 }
 
 __kernel void ckDMAS_g(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* elementHeights,
   __global float* elementPositions,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   int Slices,
   int outputL,
   int outputS,
-  float angle,
-  float probeRadius,
   float totalSamples_i,
   float horizontalExtent,
   float mult,
   char isPAImage,
   __global unsigned short* usedLines // parameters
 )
 {
   // get thread identifier
   int globalPosX = get_global_id(0);
   int globalPosY = get_global_id(1);
   int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {
     int AddSample1 = 0;
     int AddSample2 = 0;
     
     float output = 0;
     
     float s_1 = 0;
     float s_2 = 0;
     float apod_1 = 0;
 
     float l_p = (float)globalPosX / outputL * horizontalExtent;
     float s_i = (float)globalPosY / outputS * totalSamples_i;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
 
     float apod_mult = (float)apodArraySize / curUsedLines;
 
     float multiplication = 0;
 
     for (int l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
       AddSample1 = (int)sqrt(
         pow(s_i-elementHeights[l_s1]*mult, 2)
         +
         pow(mult * (l_p - elementPositions[l_s1]), 2)
       ) + (1 - isPAImage)*s_i;
       
       if (AddSample1 < inputS && AddSample1 >= 0)
       {
         s_1 = dSource[(int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)];
         apod_1 = apodArray[(int)((l_s1 - minLine)*apod_mult)];
         
         for (int l_s2 = minLine; l_s2 < maxLine; ++l_s2)
         {
           AddSample2 = (int)sqrt(
             pow(s_i-elementHeights[l_s2]*mult, 2)
             +
             pow(mult * (l_p - elementPositions[l_s2]), 2)
           ) + (1 - isPAImage)*s_i;
           if (AddSample2 < inputS && AddSample2 >= 0)
           {
             s_2 = dSource[(int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)];
             multiplication = apodArray[(int)((l_s2 - minLine)*apod_mult)] * s_2 * apod_1 * s_1;
               
             output += sqrt(fabs(multiplication)) * sign(multiplication);
           }
         }
       }
       else
         --curUsedLines;
     }
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (float)(pow((float)curUsedLines, 2) - (curUsedLines - 1));
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl b/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl
index 28a79695e6..f63b28ef36 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl
@@ -1,173 +1,171 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 __kernel void cksDMAS(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global unsigned short* usedLines,
   __global unsigned short* AddSamples,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   unsigned int Slices,
   unsigned int outputL,
   unsigned int outputS  // parameters
 )
 {
   // get thread identifier
   unsigned int globalPosX = get_global_id(0);
   unsigned int globalPosY = get_global_id(1);
   unsigned int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {	
     float l_i = (float)globalPosX / (float)outputL * (float)inputL;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
 
     float apod_mult = (float)apodArraySize / (float)curUsedLines;
 
     unsigned short Delay1 = 0;
     unsigned short Delay2 = 0;
 
     float output = 0;
     float mult = 0;
     
     float s_1 = 0;
     float s_2 = 0;
     float dSign = 0;
     float apod_1 = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
       Delay1 = AddSamples[globalPosY * (outputL / 2) + (int)(fabs(l_s1 - l_i)/(float)inputL * (float)outputL)];
       if (Delay1 < inputS && Delay1 >= 0) 
       {
         s_1 = dSource[(int)(globalPosZ * inputL * inputS + Delay1 * inputL + l_s1)];
         apod_1 = apodArray[(int)((l_s1 - minLine)*apod_mult)];
         dSign += s_1;
         
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           Delay2 = AddSamples[globalPosY * (outputL / 2) + (int)(fabs(l_s2 - l_i)/(float)inputL * (float)outputL)];
           if (Delay2 < inputS && Delay2 >= 0) 
           {
             s_2 = dSource[(int)(globalPosZ * inputL * inputS + Delay2 * inputL + l_s2)];
             
             mult = apodArray[(int)((l_s2 - minLine)*apod_mult)] * s_2 * apod_1 * s_1;
               
             output += sqrt(fabs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --curUsedLines;
     }
 
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (float)(curUsedLines * curUsedLines - (curUsedLines - 1)) * sign(dSign);
   }
 }
 
 __kernel void cksDMAS_g(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* elementHeights,
   __global float* elementPositions,
   __constant float* apodArray,
   unsigned short apodArraySize,
   unsigned int inputL,
   unsigned int inputS,
   int Slices,
   int outputL,
   int outputS,
-  float angle,
-  float probeRadius,
   float totalSamples_i,
   float horizontalExtent,
   float mult,
   char isPAImage,
   __global unsigned short* usedLines // parameters
 )
 {
   // get thread identifier
   int globalPosX = get_global_id(0);
   int globalPosY = get_global_id(1);
   int globalPosZ = get_global_id(2);
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {
     int AddSample1 = 0;
     int AddSample2 = 0;
     
     float output = 0;
     
     float s_1 = 0;
     float s_2 = 0;
     float apod_1 = 0;
 
     float l_p = (float)globalPosX / outputL * horizontalExtent;
     float s_i = (float)globalPosY / outputS * totalSamples_i;
 
     unsigned short curUsedLines = usedLines[globalPosY * 3 * outputL + 3 * globalPosX];
     unsigned short minLine = usedLines[globalPosY * 3 * outputL + 3 * globalPosX + 1];
     unsigned short maxLine = usedLines[globalPosY * 3 *outputL + 3 * globalPosX + 2];
 
     float apod_mult = (float)apodArraySize / curUsedLines;
     float dSign = 0;
 
     float multiplication = 0;
 
     for (int l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
       AddSample1 = (int)sqrt(
         pow(s_i-elementHeights[l_s1]*mult, 2)
         +
         pow(mult * (l_p - elementPositions[l_s1]), 2)
       ) + (1 - isPAImage)*s_i;
       
       if (AddSample1 < inputS && AddSample1 >= 0)
       {
         s_1 = dSource[(int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)];
         apod_1 = apodArray[(int)((l_s1 - minLine)*apod_mult)];
         dSign += s_1;
         
         for (int l_s2 = minLine; l_s2 < maxLine; ++l_s2)
         {
           AddSample2 = (int)sqrt(
             pow(s_i-elementHeights[l_s2]*mult, 2)
             +
             pow(mult * (l_p - elementPositions[l_s2]), 2)
           ) + (1 - isPAImage)*s_i;
           if (AddSample2 < inputS && AddSample2 >= 0)
           {
             s_2 = dSource[(int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)];
             multiplication = apodArray[(int)((l_s2 - minLine)*apod_mult)] * s_2 * apod_1 * s_1;
               
             output += sqrt(fabs(multiplication)) * sign(multiplication);
           }
         }
       }
       else
         --curUsedLines;
     }
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (float)(pow((float)curUsedLines, 2) - (curUsedLines - 1)) * sign(dSign);
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
index 8721ea4e24..498ba57c5a 100644
--- a/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/OpenCLFilter/mitkPhotoacousticOCLBeamformingFilter.cpp
@@ -1,329 +1,327 @@
 /*===================================================================
 
 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_inputSlices(1),
   m_Conf(settings),
   m_InputImage(mitk::Image::New()),
   m_ApodizationBuffer(nullptr),
   m_DelaysBuffer(nullptr),
   m_UsedLinesBuffer(nullptr),
   m_ElementHeightsBuffer(nullptr),
   m_ElementPositionsBuffer(nullptr)
 {
   MITK_INFO << "Instantiating 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 };
 
   m_InputImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, dim);
 
   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 << "Instantiating OCL beamforming Filter...[Done]";
 }
 
 mitk::PhotoacousticOCLBeamformingFilter::~PhotoacousticOCLBeamformingFilter()
 {
   if (this->m_PixelCalculation)
   {
     clReleaseKernel(m_PixelCalculation);
   }
 
   if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
   if (m_ElementHeightsBuffer) clReleaseMemObject(m_ElementHeightsBuffer);
   if (m_ElementPositionsBuffer) clReleaseMemObject(m_ElementPositionsBuffer);
 }
 
 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_context gpuContext = resources->GetContext();
 
   //Initialize the Output
   try
   {
     size_t outputSize = (size_t)m_Conf->GetReconstructionLines() * (size_t)m_Conf->GetSamplesPerLine() *
       (size_t)m_inputSlices;
     m_OutputDim[0] = m_Conf->GetReconstructionLines();
     m_OutputDim[1] = m_Conf->GetSamplesPerLine();
     m_OutputDim[2] = m_inputSlices;
     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;
   }
 
   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]{ 1 };
     m_ApodArraySize = 1;
   }
 
   if (m_ApodizationBuffer) clReleaseMemObject(m_ApodizationBuffer);
 
   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);
 
   if (m_ElementHeightsBuffer) clReleaseMemObject(m_ElementHeightsBuffer);
   this->m_ElementHeightsBuffer = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_Conf->GetTransducerElements(), const_cast<float*>(m_Conf->GetElementHeights()), &clErr);
   CHECK_OCL_ERR(clErr);
 
   if (m_ElementPositionsBuffer) clReleaseMemObject(m_ElementPositionsBuffer);
   this->m_ElementPositionsBuffer = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_Conf->GetTransducerElements(), const_cast<float*>(m_Conf->GetElementPositions()), &clErr);
   CHECK_OCL_ERR(clErr);
   // calculate used lines
 
   m_UsedLinesCalculation->SetElementPositionsBuffer(m_ElementPositionsBuffer);
   m_UsedLinesCalculation->SetElementHeightsBuffer(m_ElementHeightsBuffer);
   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();
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::Execute()
 {
   cl_int clErr = 0;
   UpdateDataBuffers();
   if (m_Conf->GetGeometry() == mitk::BeamformingSettings::ProbeGeometry::Linear)
   {
     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), &(m_inputSlices));
     clErr |= clSetKernelArg(this->m_PixelCalculation, 9, sizeof(cl_uint), &(reconstructionLines));
     clErr |= clSetKernelArg(this->m_PixelCalculation, 10, sizeof(cl_uint), &(samplesPerLine));
   }
   else
   {
     int reconstructionLines = this->m_Conf->GetReconstructionLines();
     int samplesPerLine = this->m_Conf->GetSamplesPerLine();
     float angle = this->m_Conf->GetAngle();
     float probeRadius = this->m_Conf->GetProbeRadius();
     float totalSamples_i = (float)(m_Conf->GetReconstructionDepth()) / (float)(m_Conf->GetSpeedOfSound() * m_Conf->GetTimeSpacing());
     totalSamples_i = totalSamples_i <= m_Conf->GetInputDim()[1] ? totalSamples_i : m_Conf->GetInputDim()[1];
     float horizontalExtent = m_Conf->GetHorizontalExtent();
     float mult = 1 / (this->m_Conf->GetTimeSpacing() * this->m_Conf->GetSpeedOfSound());
     char isPAImage = (char)m_Conf->GetIsPhotoacousticImage();
 
     clErr = clSetKernelArg(this->m_PixelCalculation, 2, sizeof(cl_mem), &(this->m_ElementHeightsBuffer));
     clErr |= clSetKernelArg(this->m_PixelCalculation, 3, sizeof(cl_mem), &(this->m_ElementPositionsBuffer));
     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_int), &(m_inputSlices));
     clErr |= clSetKernelArg(this->m_PixelCalculation, 9, sizeof(cl_int), &(reconstructionLines));
     clErr |= clSetKernelArg(this->m_PixelCalculation, 10, sizeof(cl_int), &(samplesPerLine));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 11, sizeof(cl_float), &(angle));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 12, sizeof(cl_float), &(probeRadius));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 13, sizeof(cl_float), &(totalSamples_i));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 14, sizeof(cl_float), &(horizontalExtent));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 15, sizeof(cl_float), &(mult));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 16, sizeof(cl_char), &(isPAImage));
-    clErr |= clSetKernelArg(this->m_PixelCalculation, 17, sizeof(cl_mem), &(this->m_UsedLinesBuffer));
+    clErr |= clSetKernelArg(this->m_PixelCalculation, 11, sizeof(cl_float), &(totalSamples_i));
+    clErr |= clSetKernelArg(this->m_PixelCalculation, 12, sizeof(cl_float), &(horizontalExtent));
+    clErr |= clSetKernelArg(this->m_PixelCalculation, 13, sizeof(cl_float), &(mult));
+    clErr |= clSetKernelArg(this->m_PixelCalculation, 14, sizeof(cl_char), &(isPAImage));
+    clErr |= clSetKernelArg(this->m_PixelCalculation, 15, sizeof(cl_mem), &(this->m_UsedLinesBuffer));
   }
   // execute the filter on a 2D/3D NDRange
   if (m_OutputDim[2] == 1 || m_ChunkSize[2] == 1)
   {
     if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 2, m_ChunkSize, m_inputSlices, 50))
       mitkThrow() << "openCL Error when executing Kernel";
   }
   else
   {
     if (!this->ExecuteKernelChunksInBatches(m_PixelCalculation, 3, m_ChunkSize, m_inputSlices, 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()
 {
   bool buildErr = true;
   cl_int clErr = 0;
 
   if (OclFilter::Initialize())
   {
     if (m_Conf->GetGeometry() == mitk::BeamformingSettings::ProbeGeometry::Linear)
     {
       switch (m_Conf->GetAlgorithm())
       {
       case BeamformingSettings::BeamformingAlgorithm::DAS:
       {
         MITK_INFO << "DAS bf";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS", &clErr);
         break;
       }
       case BeamformingSettings::BeamformingAlgorithm::DMAS:
       {
         MITK_INFO << "DMAS bf";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMAS", &clErr);
         break;
       }
       case BeamformingSettings::BeamformingAlgorithm::sDMAS:
       {
         MITK_INFO << "sDMAS bf";
         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;
       }
       }
     }
     else
     {
       switch (m_Conf->GetAlgorithm())
       {
       case BeamformingSettings::BeamformingAlgorithm::DAS:
       {
         MITK_INFO << "DAS bf";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS_g", &clErr);
         break;
       }
       case BeamformingSettings::BeamformingAlgorithm::DMAS:
       {
         MITK_INFO << "DMAS bf";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMAS_g", &clErr);
         break;
       }
       case BeamformingSettings::BeamformingAlgorithm::sDMAS:
       {
         MITK_INFO << "sDMAS bf";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "cksDMAS_g", &clErr);
         break;
       }
       default:
       {
         MITK_INFO << "No beamforming algorithm specified, setting to DAS";
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDAS_g", &clErr);
         break;
       }
       }
     }
     buildErr |= CHECK_OCL_ERR(clErr);
   }
 
   CHECK_OCL_ERR(clErr);
 
   return (OclFilter::IsInitialized() && buildErr);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(mitk::Image::Pointer image)
 {
   OclDataSetToDataSetFilter::SetInput(image);
   m_InputImage = image;
   m_inputSlices = image->GetDimension(2);
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(void* data, unsigned int* dimensions, unsigned int BpE)
 {
   OclDataSetToDataSetFilter::SetInput(data, dimensions[0] * dimensions[1] * dimensions[2], BpE);
 }
 
 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::CopyMemory);
     free(pData);
   }
 
   MITK_DEBUG << "Image Initialized.";
 
   return outputImage;
 }
 
 void* mitk::PhotoacousticOCLBeamformingFilter::GetOutput()
 {
   return OclDataSetToDataSetFilter::GetOutput();
 }
 #endif