diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl b/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
index 56492ff8fb..43927adc8a 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DAS.cl
@@ -1,129 +1,127 @@
 /*===================================================================
 
 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_i = 0;
     float l_p = 0;
     float s_i = 0;
 
     float apod_mult = 1;
     
     float output = 0;
 
-    l_i = (float)globalPosX / outputL * inputL;
     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 0a925ddadc..dee635936e 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMAS.cl
@@ -1,170 +1,169 @@
 /*===================================================================
 
 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_i = (float)globalPosX / outputL * inputL;
     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 bb6096b3c6..28a79695e6 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/sDMAS.cl
@@ -1,174 +1,173 @@
 /*===================================================================
 
 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_i = (float)globalPosX / outputL * inputL;
     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/utils/mitkBeamformingUtils.cpp b/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
index 3162ce7f32..b367bb57f3 100644
--- a/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/utils/mitkBeamformingUtils.cpp
@@ -1,435 +1,420 @@
 /*===================================================================
 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;
 }
 
 unsigned short* mitk::BeamformingUtils::MinMaxLines(const mitk::BeamformingSettings::Pointer config)
 {
   int outputL = (int)config->GetReconstructionLines();
   int outputS = (int)config->GetSamplesPerLine();
 
   unsigned short* dDest = new unsigned short[outputL * outputS * 2];
 
   int inputL = (int)config->GetInputDim()[0];
-  int inputS = (int)config->GetInputDim()[1];
   
   float horizontalExtent = config->GetHorizontalExtent();
   float verticalExtent = config->GetReconstructionDepth();
 
   float probeRadius = config->GetProbeRadius();
   float* elementHeights = config->GetElementHeights();
   float* elementPositions = config->GetElementPositions();
 
   float cos_deg = std::cos(config->GetAngle() / 2.f / 360 * 2 * itk::Math::pi);
 
   float cos = 0;
   float a = 0;
   float d = 0;
 
   for (int x = 0; x < outputL; ++x)
   {
     for (int y = 0; y < outputS; ++y)
     {
       float l_p = (float)x / outputL * horizontalExtent;
       float s_p = (float)y / (float)outputS * verticalExtent;
 
       int maxLine = inputL;
       int minLine = 0;
 
       for (int l_s = 0; l_s < inputL; l_s += 32)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
 
         if (cos > cos_deg)
         {
           minLine = l_s - 32;
           if (minLine < 0)
             minLine = 0;
           break;
         }
       }
       for (int l_s = minLine; l_s < inputL; l_s += 8)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
 
         if (cos > cos_deg)
         {
           minLine = l_s - 8;
           if (minLine < 0)
             minLine = 0;
           break;
         }
       }
       for (int l_s = minLine; l_s < inputL; l_s += 1)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
 
         if (cos > cos_deg)
         {
           minLine = l_s;
           break;
         }
       }
 
       for (int l_s = inputL; l_s >= 0; l_s -= 32)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
         cos = 0;
 
         if (cos > cos_deg)
         {
           maxLine = l_s + 32;
           if (maxLine > inputL)
             minLine = inputL;
           break;
         }
       }
       for (int l_s = maxLine; l_s >= 0; l_s -= 8)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
         cos = 0;
 
         if (cos > cos_deg)
         {
           maxLine = l_s + 8;
           if (maxLine > inputL)
             minLine = inputL;
           break;
         }
       }
       for (int l_s = maxLine; l_s >= 0; l_s -= 1)
       {
         a = sqrt((probeRadius - s_p)*(probeRadius - s_p) + (l_p - horizontalExtent / 2)*(l_p - horizontalExtent / 2));
         d = sqrt((s_p - elementHeights[l_s])*(s_p - elementHeights[l_s]) + (l_p - elementPositions[l_s])*(l_p - elementPositions[l_s]));
         cos = (d*d + probeRadius * probeRadius - a * a) / (2 * probeRadius*d);
         cos = 0;
 
         if (cos > cos_deg)
         {
           maxLine = l_s;
           break;
         }
       }
 
       dDest[y * 2 * outputL + 2 * x] = (unsigned short)minLine; //minLine
       dDest[y * 2 * outputL + 2 * x + 1] = (unsigned short)maxLine; //maxLine
     }
   }
   return dDest;
 }
 
 void mitk::BeamformingUtils::DASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
   const short& line, const mitk::BeamformingSettings::Pointer config)
 {
   const float* apodisation = config->GetApodizationFunction();
   const short apodArraySize = config->GetApodizationArraySize();
 
   const float* elementHeights = config->GetElementHeights();
   const float* elementPositions = config->GetElementPositions();
 
   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 l_p = 0;
   float s_i = 0;
 
   float apod_mult = 1;
 
-  float probeRadius = config->GetProbeRadius();
-
   short usedLines = (maxLine - minLine);
 
   float totalSamples_i = (float)(config->GetReconstructionDepth()) / (float)(config->GetSpeedOfSound() * config->GetTimeSpacing());
   totalSamples_i = totalSamples_i <= inputS ? totalSamples_i : inputS;
 
-  l_i = (float)line / outputL * inputL;
   l_p = (float)line / outputL * config->GetHorizontalExtent();
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * totalSamples_i;
 
     minLine = config->GetMinMaxLines()[2*sample*(short)outputL + 2*line];
     maxLine = config->GetMinMaxLines()[2*sample*(short)outputL + 2*line + 1];
     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-elementHeights[l_s]/(config->GetSpeedOfSound()*config->GetTimeSpacing()), 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound())) * (l_p - elementPositions[l_s]), 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::DMASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
   const short& line, const mitk::BeamformingSettings::Pointer config)
 {
   const float* apodisation = config->GetApodizationFunction();
   const short apodArraySize = config->GetApodizationArraySize();
 
   const float* elementHeights = config->GetElementHeights();
   const float* elementPositions = config->GetElementPositions();
 
   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 l_p = 0;
   float s_i = 0;
 
   float apod_mult = 1;
 
-  float probeRadius = config->GetProbeRadius();
-
   float mult = 0;
 
   short usedLines = (maxLine - minLine);
 
   float totalSamples_i = (float)(config->GetReconstructionDepth()) /
     (float)(config->GetSpeedOfSound() * config->GetTimeSpacing());
   totalSamples_i = totalSamples_i <= inputS ? totalSamples_i : inputS;
 
-  l_i = (float)line / outputL * inputL;
   l_p = (float)line / outputL * config->GetHorizontalExtent();
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * totalSamples_i;
 
     minLine = config->GetMinMaxLines()[2 * sample*(short)outputL + 2 * line];
     maxLine = config->GetMinMaxLines()[2 * sample*(short)outputL + 2 * line + 1];
     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] = (int)sqrt(
         pow(s_i - elementHeights[l_s + minLine] / (config->GetSpeedOfSound()*config->GetTimeSpacing()), 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound())) * (l_p - elementPositions[l_s + minLine]), 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::sDMASSphericalLine(
   float* input, float* output, float inputDim[2], float outputDim[2],
   const short& line, const mitk::BeamformingSettings::Pointer config)
 {
   const float* apodisation = config->GetApodizationFunction();
   const short apodArraySize = config->GetApodizationArraySize();
 
   const float* elementHeights = config->GetElementHeights();
   const float* elementPositions = config->GetElementPositions();
 
   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 l_p = 0;
   float s_i = 0;
 
   float apod_mult = 1;
 
-  float probeRadius = config->GetProbeRadius();
-  bool concave = config->GetGeometry() == mitk::BeamformingSettings::ProbeGeometry::Concave;
-  float elementHeight = 0;
-
   float mult = 0;
 
   short usedLines = (maxLine - minLine);
 
   float totalSamples_i = (float)(config->GetReconstructionDepth()) /
     (float)(config->GetSpeedOfSound() * config->GetTimeSpacing());
   totalSamples_i = totalSamples_i <= inputS ? totalSamples_i : inputS;
 
-  l_i = (float)line / outputL * inputL;
   l_p = (float)line / outputL * config->GetHorizontalExtent();
 
   for (short sample = 0; sample < outputS; ++sample)
   {
     s_i = (float)sample / outputS * totalSamples_i;
 
     minLine = config->GetMinMaxLines()[2 * sample*(short)outputL + 2 * line];
     maxLine = config->GetMinMaxLines()[2 * sample*(short)outputL + 2 * line + 1];
     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] = (int)sqrt(
         pow(s_i - elementHeights[l_s + minLine] / (config->GetSpeedOfSound()*config->GetTimeSpacing()), 2)
         +
         pow((1 / (config->GetTimeSpacing()*config->GetSpeedOfSound())) * (l_p - elementPositions[l_s + minLine]), 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/test/mitkPAFilterServiceTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
index 70d0dd7f1b..d43501a92d 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
@@ -1,123 +1,124 @@
 /*===================================================================
 
 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;
   mitk::BeamformingSettings::Pointer m_BeamformingSettings;
   unsigned int* inputDimensions;
   const int xDim = 16;
   const int yDim = 128;
   const int length = yDim * xDim;
 
 public:
 
   void setUp() override
   {
     m_PhotoacousticFilterService = mitk::PhotoacousticFilterService::New();
     m_BeamformingSettings = CreateBeamformingSettings();
   }
 
   mitk::BeamformingSettings::Pointer CreateBeamformingSettings()
   {
     inputDimensions = new unsigned int[length];
     inputDimensions[0] = yDim;
     inputDimensions[1] = xDim;
     mitk::BeamformingSettings::Pointer outputSettings = mitk::BeamformingSettings::New(
       (float)(0.3 / 1000),
       (float)(1500),
       (float)(0.0125 / 1000000),
       27,
       true,
       3000,
       128,
       inputDimensions,
       yDim * (0.0125 / 1000000) * (1500),
       false,
       16,
-      mitk::BeamformingSettings::DelayCalc::Spherical,
       mitk::BeamformingSettings::Apodization::Box,
       128,
-      mitk::BeamformingSettings::BeamformingAlgorithm::DAS);
+      mitk::BeamformingSettings::BeamformingAlgorithm::DAS,
+      mitk::BeamformingSettings::ProbeGeometry::Linear,
+      0);
 
     return outputSettings;
   }
 
   void testRunning()
   {
     float* testArray = new float[length];
     for (int i = 0; i < length; ++i)
     {
       testArray[i] = 0;
     }
 
     mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
     mitk::Image::Pointer testImage = mitk::Image::New();
     testImage->Initialize(pixelType, 2, inputDimensions);
     testImage->SetImportSlice(testArray, 0, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
     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);
     }
 
     auto output = m_PhotoacousticFilterService->ApplyBeamforming(testImage, m_BeamformingSettings);
 
     mitk::ImageReadAccessor readAccess(output);
     const float* outputArray = (const float*)readAccess.GetData();
 
     for (int i = 0; i < length; ++i)
     {
       CPPUNIT_ASSERT_MESSAGE(std::string("Output array not correct: " + std::to_string(abs(outputArray[i]))), abs(outputArray[i]) < 1e-5f);
     }
   }
 
   void tearDown() override
   {
     m_PhotoacousticFilterService = nullptr;
     delete[] inputDimensions;
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPAFilterService)