diff --git a/Modules/OpenCL/mitkOclFilter.cpp b/Modules/OpenCL/mitkOclFilter.cpp
index 717baa051d..d1b1c23aab 100644
--- a/Modules/OpenCL/mitkOclFilter.cpp
+++ b/Modules/OpenCL/mitkOclFilter.cpp
@@ -1,286 +1,284 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //Ocl
 #include "mitkOclFilter.h"
 #include "mitkOclUtils.h"
 #include "mitkOpenCLActivator.h"
 
 //Mitk
 #include <mitkLogMacros.h>
 #include <mitkConfig.h>
 
 //usService
 #include "usServiceReference.h"
 #include <usServiceRegistration.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 mitk::OclFilter::OclFilter()
   : m_ClCompilerFlags(""),
     m_ClProgram(nullptr),
     m_CommandQue(nullptr),
     m_FilterID("mitkOclFilter"),
     m_Preambel(" "),
     m_Initialized(false)
 {
 }
 
 mitk::OclFilter::OclFilter(const char* filename)
   : m_ClCompilerFlags(""),
     m_ClProgram(nullptr),
     m_CommandQue(nullptr),
     m_FilterID(filename),
     m_Preambel(" "),
     m_Initialized(false)
 {
   m_ClFiles.push_back(filename);
 }
 
 mitk::OclFilter::~OclFilter()
 {
   MITK_DEBUG << "OclFilter Destructor";
 
   // release program
   if (m_ClProgram)
   {
     us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
     OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
     // remove program from storage
     resources->RemoveProgram(m_FilterID);
   }
 }
 
 bool mitk::OclFilter::ExecuteKernel( cl_kernel kernel, unsigned int workSizeDim )
 {
   cl_int clErr = 0;
 
   clErr = clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
                                   nullptr, this->m_GlobalWorkSize, m_LocalWorkSize, 0, nullptr, nullptr);
 
   CHECK_OCL_ERR( clErr );
 
   return ( clErr == CL_SUCCESS );
 }
 
 bool mitk::OclFilter::ExecuteKernelChunks( cl_kernel kernel, unsigned int workSizeDim, size_t* chunksDim )
 {
   size_t offset[3] ={0, 0, 0};
   cl_int clErr = 0;
 
   if(workSizeDim == 2)
   {
     for(offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
     {
       for(offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
       {
-        clErr = clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
+        clErr |= clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
                                         offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
-        CHECK_OCL_ERR( clErr );
       }
     }
   }
   else if(workSizeDim == 3)
   {
     for(offset[0] = 0; offset[0] < m_GlobalWorkSize[0]; offset[0] += chunksDim[0])
     {
       for(offset[1] = 0; offset[1] < m_GlobalWorkSize[1]; offset[1] += chunksDim[1])
       {
         for(offset[2] = 0; offset[2] < m_GlobalWorkSize[2]; offset[2] += chunksDim[2])
         {
-          clErr = clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
+          clErr |= clEnqueueNDRangeKernel( this->m_CommandQue, kernel, workSizeDim,
                                           offset, chunksDim, m_LocalWorkSize, 0, nullptr, nullptr);
-          CHECK_OCL_ERR( clErr );
-
-          MITK_INFO<< "started new chunk";
         }
       }
     }
   }
 
+  CHECK_OCL_ERR(clErr);
+
   return ( clErr == CL_SUCCESS );
 }
 
 
 bool mitk::OclFilter::Initialize()
 {
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   m_CommandQue = resources->GetCommandQueue();
 
   cl_int clErr = 0;
   m_Initialized = CHECK_OCL_ERR(clErr);
 
   if ( m_ClFiles.empty())
   {
     MITK_ERROR<<"No OpenCL Source FILE specified";
     return false;
   }
 
   if (m_ClProgram == nullptr)
   {
     try
     {
       this->m_ClProgram = resources->GetProgram( this->m_FilterID );
     }
     catch(const mitk::Exception& e)
     {
       MITK_INFO << "Program not stored in resource manager, compiling. " << e;
       this->CompileSource();
     }
   }
 
   return m_Initialized;
 }
 
 void mitk::OclFilter::LoadSourceFiles(CStringList &sourceCode, ClSizeList &sourceCodeSize)
 {
   for( CStringList::iterator it = m_ClFiles.begin(); it != m_ClFiles.end(); ++it )
   {
     MITK_DEBUG << "Load file :" << *it;
     us::ModuleResource mdr = GetModule()->GetResource(*it);
 
     if( !mdr.IsValid() )
       MITK_WARN << "Could not load resource: " << mdr.GetName() << " is invalid!";
 
     us::ModuleResourceStream rss(mdr);
 
     // read resource file to a string
     std::istreambuf_iterator<char> eos;
     std::string source(std::istreambuf_iterator<char>(rss), eos);
 
     // add preambel and build up string to compile
     std::string src(m_Preambel);
     src.append("\n");
     src.append(source);
 
     // allocate new char buffer
     char* tmp = new char[src.size() + 1];
     strcpy(tmp,src.c_str());
 
     // add source to list
     sourceCode.push_back((const char*)tmp);
     sourceCodeSize.push_back(src.size());
   }
 }
 
 void mitk::OclFilter::CompileSource()
 {
   // helper variable
   int clErr = 0;
   CStringList sourceCode;
   ClSizeList sourceCodeSize;
 
   if (m_ClFiles.empty())
   {
     MITK_ERROR("ocl.filter") << "No shader source file was set";
     return;
   }
 
   //get a valid opencl context
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   cl_context gpuContext = resources->GetContext();
   // load the program source from file
   LoadSourceFiles(sourceCode, sourceCodeSize);
 
   if ( !sourceCode.empty() )
   {
     // create program from all files in the file list
     m_ClProgram = clCreateProgramWithSource(gpuContext, sourceCode.size(), &sourceCode[0], &sourceCodeSize[0], &clErr);
     CHECK_OCL_ERR(clErr);
 
     // build the source code
     MITK_DEBUG << "Building Program Source";
     std::string compilerOptions = "";
     compilerOptions.append(m_ClCompilerFlags);
 
     MITK_DEBUG("ocl.filter") << "cl compiler flags: " << compilerOptions.c_str();
 
     clErr = clBuildProgram(m_ClProgram, 0, nullptr, compilerOptions.c_str(), nullptr, nullptr);
     CHECK_OCL_ERR(clErr);
 
     // if OpenCL Source build failed
     if (clErr != CL_SUCCESS)
     {
       MITK_ERROR("ocl.filter") << "Failed to build source";
       oclLogBuildInfo(m_ClProgram, resources->GetCurrentDevice() );
       oclLogBinary(m_ClProgram, resources->GetCurrentDevice() );
       m_Initialized = false;
     }
 
     // store the succesfully build program into the program storage provided by the resource service
     resources->InsertProgram(m_ClProgram, m_FilterID, true);
 
     // free the char buffers with the source code
     for( CStringList::iterator it = sourceCode.begin(); it != sourceCode.end(); ++it )
     {
       delete[] *it;
     }
   }
   else
   {
     MITK_ERROR("ocl.filter") << "Could not load from source";
     m_Initialized = false;
   }
 }
 
 void mitk::OclFilter::SetWorkingSize(unsigned int locx, unsigned int dimx, unsigned int locy, unsigned int dimy, unsigned int locz, unsigned int dimz)
 {
   // set the local work size
   this->m_LocalWorkSize[0] = locx;
   this->m_LocalWorkSize[1] = locy;
   this->m_LocalWorkSize[2] = locz;
 
   this->m_GlobalWorkSize[0] = dimx;
   this->m_GlobalWorkSize[1] = dimy;
   this->m_GlobalWorkSize[2] = dimz;
 
   // estimate the global work size
   this->m_GlobalWorkSize[0] = iDivUp( dimx, this->m_LocalWorkSize[0]) * this->m_LocalWorkSize[0];
 
   if ( dimy > 1)
     this->m_GlobalWorkSize[1] = iDivUp( dimy, this->m_LocalWorkSize[1]) * this->m_LocalWorkSize[1];
   if( dimz > 1 )
     this->m_GlobalWorkSize[2] = iDivUp( dimz, this->m_LocalWorkSize[2]) * this->m_LocalWorkSize[2];
 }
 
 void mitk::OclFilter::SetSourcePreambel(const char* preambel)
 {
   this->m_Preambel = preambel;
 }
 
 void mitk::OclFilter::AddSourceFile(const char* filename)
 {
   m_ClFiles.push_back(filename);
 }
 
 void mitk::OclFilter::SetCompilerFlags(const char* flags)
 {
   m_ClCompilerFlags = flags;
 }
 
 
 bool mitk::OclFilter::IsInitialized()
 {
   return m_Initialized;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
index dff7c700f8..b357c701a2 100644
--- a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
+++ b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
@@ -1,207 +1,211 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifdef PHOTOACOUSTICS_USE_GPU
 
 #include "mitkPhotoacousticOCLBeamformer.h"
 #include "usServiceReference.h"
 
 mitk::PhotoacousticOCLBeamformingFilter::PhotoacousticOCLBeamformingFilter()
 : m_PixelCalculation( NULL ), m_InputImage(mitk::Image::New())
 {
   this->AddSourceFile("DASQuadratic.cl");
   this->AddSourceFile("DMASQuadratic.cl");
   this->AddSourceFile("DASspherical.cl");
   this->AddSourceFile("DMASspherical.cl");
 
   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);
 
   this->m_FilterID = "PixelCalculation";
 }
 
 mitk::PhotoacousticOCLBeamformingFilter::~PhotoacousticOCLBeamformingFilter()
 {
   if ( this->m_PixelCalculation )
   {
     clReleaseKernel( m_PixelCalculation );
   }
 }
 
 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::Execute()
 {
   cl_int clErr = 0;
 
   try
   {
     this->InitExec(this->m_PixelCalculation, m_OutputDim, sizeof(float));
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Caught exception while initializing filter: " << e.what();
     return;
   }
 
   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_ApodArraySize = 1;
   }
 
   us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
   cl_context gpuContext = resources->GetContext();
 
   cl_mem cl_input = clCreateBuffer(gpuContext, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, sizeof(float) * m_ApodArraySize, m_Apodisation, &clErr);
   CHECK_OCL_ERR(clErr);
 
   // set kernel arguments
   clErr = clSetKernelArg( this->m_PixelCalculation, 2, sizeof(cl_mem), &cl_input);
   clErr |= clSetKernelArg( this->m_PixelCalculation, 3, sizeof(cl_ushort), &(this->m_ApodArraySize) );
   clErr |= clSetKernelArg( this->m_PixelCalculation, 4, sizeof(cl_float), &(this->m_SpeedOfSound) );
   clErr |= clSetKernelArg( this->m_PixelCalculation, 5, sizeof(cl_float), &(this->m_TimeSpacing) );
   clErr |= clSetKernelArg( this->m_PixelCalculation, 6, sizeof(cl_float), &(this->m_Pitch) );
   clErr |= clSetKernelArg( this->m_PixelCalculation, 7, sizeof(cl_float), &(this->m_Angle) );
   clErr |= clSetKernelArg( this->m_PixelCalculation, 8, sizeof(cl_ushort), &(this->m_PAImage));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 9, sizeof(cl_ushort), &(this->m_TransducerElements));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 10, sizeof(cl_uint), &(this->m_InputDim[0]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 11, sizeof(cl_uint), &(this->m_InputDim[1]));
   clErr |= clSetKernelArg(this->m_PixelCalculation, 12, sizeof(cl_uint), &(this->m_InputDim[2]));
+  clErr |= clSetKernelArg(this->m_PixelCalculation, 13, sizeof(cl_uint), &(this->m_OutputDim[0]));
+  clErr |= clSetKernelArg(this->m_PixelCalculation, 14, sizeof(cl_uint), &(this->m_OutputDim[1]));
 
   CHECK_OCL_ERR( clErr );
 
+  size_t chunkSize[3] = { 128, 128, 8 };
+
   // execute the filter on a 3D NDRange
   if (m_OutputDim[2] == 1)
-    this->ExecuteKernel(m_PixelCalculation, 2);
+    this->ExecuteKernelChunks(m_PixelCalculation, 2, chunkSize);
   else
-    this->ExecuteKernel(m_PixelCalculation, 3);
+    this->ExecuteKernelChunks(m_PixelCalculation, 3, chunkSize);
   
   // 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() )
   {
     switch (m_Algorithm)
     {
       case BeamformingAlgorithm::DASQuad:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDASQuad", &clErr);
         break;
       }
       case BeamformingAlgorithm::DMASQuad:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMASQuad", &clErr);
         break;
       }
       case BeamformingAlgorithm::DASSphe:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDASSphe", &clErr);
         break;
       }
       case BeamformingAlgorithm::DMASSphe:
       {
         this->m_PixelCalculation = clCreateKernel(this->m_ClProgram, "ckDMASSphe", &clErr);
         break;
       }
     }
     buildErr |= CHECK_OCL_ERR( clErr );
   }
   return (OclFilter::IsInitialized() && buildErr );
 }
 
 void mitk::PhotoacousticOCLBeamformingFilter::SetInput(mitk::Image::Pointer image)
 {
   OclDataSetToDataSetFilter::SetInput(image);
 
   m_InputImage = image;
   m_InputDim[0] = m_InputImage->GetDimension(0);
   m_InputDim[1] = m_InputImage->GetDimension(1);
   m_InputDim[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_InputDim[0] = dimensions[0];
   m_InputDim[1] = dimensions[1];
   m_InputDim[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->SetGeometry(m_InputImage->GetGeometry());
     outputImage->SetImportVolume(pData, 0, 0, mitk::Image::ReferenceMemory);
   }
 
   MITK_DEBUG << "Image Initialized.";
 
   return outputImage;
 }
 #endif
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl b/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
index b97208b5bb..a205f73c75 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
@@ -1,77 +1,73 @@
 /*===================================================================
 
 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 ckDASQuad(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
   float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements,
   unsigned int inputL,
   unsigned int inputS,
-  unsigned int Slices // parameters
+  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);
-  
-  unsigned short outputS = get_global_size(1);
-  unsigned short outputL = get_global_size(0);
-
-  // create an image sampler
-  const sampler_t defaultSampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST ;
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {	
     float l_i = (float)globalPosX / outputL * inputL;
     float s_i = (float)globalPosY / outputS * inputS / 2;
 	
     float part = (tan(Angle / 360 * 2 * M_PI) * TimeSpacing * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
     if (part < 1)
       part = 1;
 
     short maxLine = min((l_i + part) + 1, (float)inputL);
     short minLine = max((l_i - part), 0.0f);
     short usedLines = (maxLine - minLine);
     float apod_mult = apodArraySize / (maxLine - minLine);
     
     short AddSample = 0;
     
     float output = 0;
 
     float delayMultiplicator = pow(1 / (TimeSpacing*SpeedOfSound) * Pitch * TransducerElements / 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-PAImage)*s_i;
       if (AddSample < inputS && AddSample >= 0) {
         output += apodArray[(short)((l_s - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample * inputL + l_s)];
         }
       else
         --usedLines;
     }
 	  
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / usedLines;
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl b/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl
index ab1be8f62a..75770a2b4b 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl
@@ -1,77 +1,73 @@
 /*===================================================================
 
 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 ckDASSphe(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
   float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements,
   unsigned int inputL,
   unsigned int inputS,
-  unsigned int Slices // parameters
+  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);
-  
-  unsigned short outputS = get_global_size(1);
-  unsigned short outputL = get_global_size(0);
-
-  // create an image sampler
-  const sampler_t defaultSampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST ;
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {
     float l_i = (float)globalPosX / outputL * inputL;
     float s_i = (float)globalPosY / outputS * inputS / 2;
 
     float part = (tan(Angle / 360 * 2 * M_PI) * TimeSpacing * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
     if (part < 1)
       part = 1;
 
     short maxLine = min((l_i + part) + 1, (float)inputL);
     short minLine = max((l_i - part), 0.0f);
     short usedLines = (maxLine - minLine);
     float apod_mult = apodArraySize / (maxLine - minLine);
     
     short AddSample = 0;
     float output = 0;
 
     for (short l_s = minLine; l_s < maxLine; ++l_s)
     {
       AddSample = sqrt(
         pow(s_i, 2)
         +
         pow((1 / (TimeSpacing*SpeedOfSound) * ((l_s - l_i)*Pitch*TransducerElements) / inputL), 2)
       ) + (1-PAImage)*s_i;
       if (AddSample < inputS && AddSample >= 0) 
         output += apodArray[(short)((l_s - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample * inputL + l_s)];
       else
         --usedLines;
     }
 	
     dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / usedLines;
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl b/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl
index e8ed09ae2a..87536d6730 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl
@@ -1,90 +1,84 @@
 /*===================================================================
 
 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 ckDMASQuad(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
   float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements,
   unsigned int inputL,
   unsigned int inputS,
-  unsigned int Slices // parameters
+  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);
-  
-  unsigned short outputS = get_global_size(1);
-  unsigned short outputL = get_global_size(0);
-
-  // create an image sampler
-  const sampler_t defaultSampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST ;
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
   {	
     float l_i = (float)globalPosX / outputL * inputL;
     float s_i = (float)globalPosY / outputS * inputS / 2;
-
+	
     float part = (tan(Angle / 360 * 2 * M_PI) * TimeSpacing * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
     if (part < 1)
       part = 1;
 
     short maxLine = min((l_i + part) + 1, (float)inputL);
     short minLine = max((l_i - part), 0.0f);
     short usedLines = (maxLine - minLine);
     float apod_mult = apodArraySize / (maxLine - minLine);
-	
-    float delayMultiplicator = pow((1 / (TimeSpacing*SpeedOfSound) * Pitch * TransducerElements / inputL), 2) / s_i / 2;
-	
-    float mult = 0;
+    
+    short AddSample1 = 0;
+    short AddSample2 = 0;
+    
     float output = 0;
-    float AddSample1 = 0;
-    float AddSample2 = 0;
-	
-    for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
+    float mult = 0;
+
+    float delayMultiplicator = pow(1 / (TimeSpacing*SpeedOfSound) * Pitch * TransducerElements / inputL, 2) / s_i / 2;
+
+    for (short l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
       AddSample1 = delayMultiplicator * pow((l_s1 - l_i), 2) + s_i + (1-PAImage)*s_i;
-      if (AddSample1 < inputS && AddSample1 >= 0)
-      {
+      if (AddSample1 < inputS && AddSample1 >= 0) {
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
           AddSample2 = delayMultiplicator * pow((l_s2 - l_i), 2) + s_i + (1-PAImage)*s_i;
-          if (AddSample2 < inputS && AddSample2 >= 0)
-          {
-            mult = dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)]
-              * apodArray[(short)((l_s2 - minLine)*apod_mult)]
-              * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)]
-              * apodArray[(short)((l_s1 - minLine)*apod_mult)];
+          if (AddSample1 < inputS && AddSample1 >= 0) {
+            mult = apodArray[(short)((l_s2 - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)]
+              * apodArray[(short)((l_s1 - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)];
             output += sqrt(mult * ((float)(mult>0)-(float)(mult<0))) * ((mult > 0) - (mult < 0));
+          
           }
         }
       }
       else
         --usedLines;
     }
-		
-    dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = 10 * output / (pow((float)usedLines, 2.0f) - (usedLines - 1));
+	  
+    dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (pow((float)usedLines, 2.0f) - (usedLines - 1));
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl b/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
index 8d74488e57..a9ae09fa98 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
@@ -1,96 +1,94 @@
 /*===================================================================
 
 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 ckDMASSphe(
   __global float* dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
   float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements,
   unsigned int inputL,
   unsigned int inputS,
-  unsigned int Slices // parameters
+  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);
-  
-  unsigned short outputS = get_global_size(1);
-  unsigned short outputL = get_global_size(0);
-
-  // create an image sampler
-  const sampler_t defaultSampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST ;
 
   // terminate non-valid threads
   if ( globalPosX < outputL && globalPosY < outputS && globalPosZ < Slices )
-  {
+  {	
     float l_i = (float)globalPosX / outputL * inputL;
     float s_i = (float)globalPosY / outputS * inputS / 2;
-
+	
     float part = (tan(Angle / 360 * 2 * M_PI) * TimeSpacing * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
     if (part < 1)
       part = 1;
 
     short maxLine = min((l_i + part) + 1, (float)inputL);
     short minLine = max((l_i - part), 0.0f);
     short usedLines = (maxLine - minLine);
     float apod_mult = apodArraySize / (maxLine - minLine);
     
-    float mult = 0;
+    short AddSample1 = 0;
+    short AddSample2 = 0;
+    
     float output = 0;
-    float AddSample1 = 0;
-    float AddSample2 = 0;
+    float mult = 0;
 
-    for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
+    float delayMultiplicator = pow(1 / (TimeSpacing*SpeedOfSound) * Pitch * TransducerElements / inputL, 2) / s_i / 2;
+
+    for (short l_s1 = minLine; l_s1 < maxLine; ++l_s1)
     {
-	  AddSample1 = sqrt(
-        pow(s_i, 2)
-        +
-        pow((1 / (TimeSpacing*SpeedOfSound) * ((l_s1 - l_i)*Pitch*TransducerElements)/inputL), 2)
-		) + (1-PAImage)*s_i;
-      if (AddSample1 < inputS && AddSample1 >= 0)
-      {
+      AddSample1 = sqrt(
+            pow(s_i, 2)
+            +
+            pow((1 / (TimeSpacing*SpeedOfSound) * ((l_s1 - l_i)*Pitch*TransducerElements)/inputL), 2)
+			      ) + (1-PAImage)*s_i;
+      if (AddSample1 < inputS && AddSample1 >= 0) {
         for (short l_s2 = l_s1 + 1; l_s2 < maxLine; ++l_s2)
         {
-	      AddSample2 = sqrt(
+          AddSample2 = sqrt(
             pow(s_i, 2)
             +
             pow((1 / (TimeSpacing*SpeedOfSound) * ((l_s2 - l_i)*Pitch*TransducerElements)/inputL), 2)
-			) + (1-PAImage)*s_i;
-          if (AddSample2 < inputS && AddSample2 >= 0)
-          {
-            mult = dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)]
-              * apodArray[(short)((l_s2 - minLine)*apod_mult)] 
-              * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)]
-              * apodArray[(short)((l_s1 - minLine)*apod_mult)];
+			      ) + (1-PAImage)*s_i;
+          if (AddSample1 < inputS && AddSample1 >= 0) {
+            mult = apodArray[(short)((l_s2 - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample2 * inputL + l_s2)]
+              * apodArray[(short)((l_s1 - minLine)*apod_mult)] * dSource[(unsigned int)(globalPosZ * inputL * inputS + AddSample1 * inputL + l_s1)];
             output += sqrt(mult * ((float)(mult>0)-(float)(mult<0))) * ((mult > 0) - (mult < 0));
+          
           }
         }
       }
       else
         --usedLines;
     }
-	
-    dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = 10 * output / (pow((float)usedLines, 2.0f) - (usedLines - 1));
+	  
+    dDest[ globalPosZ * outputL * outputS + globalPosY * outputL + globalPosX ] = output / (pow((float)usedLines, 2.0f) - (usedLines - 1));
   }
-}
\ No newline at end of file
+}
+
+	      
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/files.cmake b/Modules/PhotoacousticsAlgorithms/files.cmake
index 08f72362af..3c39b16790 100644
--- a/Modules/PhotoacousticsAlgorithms/files.cmake
+++ b/Modules/PhotoacousticsAlgorithms/files.cmake
@@ -1,18 +1,18 @@
 set(CPP_FILES
   mitkPhotoacousticImage.cpp
   
   Algorithms/mitkPhotoacousticBeamformingFilter.cpp
   
   Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
   
   Algorithms/OCL/mitkPhotoacousticBModeFilter.cpp
 )
 
 set(RESOURCE_FILES
   DASQuadratic.cl
   DMASQuadratic.cl
-  DASspherical.cl
-  DMASspherical.cl
+  DASSpherical.cl
+  DMASSpherical.cl
   BModeAbs.cl
   BModeAbsLog.cl
 )
\ No newline at end of file