diff --git a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
index b7088bfe1d..37f705233c 100644
--- a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
+++ b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.cpp
@@ -1,177 +1,177 @@
 /*===================================================================
 
 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 "mitkPhotoacousticOCLBeamformer.h"
 #include "usServiceReference.h"
 
 mitk::PhotoacousticOCLBeamformer::PhotoacousticOCLBeamformer()
 : m_PixelCalculation( NULL )
 {
   this->AddSourceFile("DASQuadratic.cl");
   this->AddSourceFile("DMASQuadratic.cl");
   this->AddSourceFile("DASspherical.cl");
   this->AddSourceFile("DMASspherical.cl");
 
   this->m_FilterID = "PixelCalculation";
 }
 
 mitk::PhotoacousticOCLBeamformer::~PhotoacousticOCLBeamformer()
 {
   if ( this->m_PixelCalculation )
   {
     clReleaseKernel( m_PixelCalculation );
   }
 }
 
 void mitk::PhotoacousticOCLBeamformer::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::PhotoacousticOCLBeamformer::Execute()
 {
   cl_int clErr = 0;
 
   try
   {
     this->InitExec(this->m_PixelCalculation, m_OutputDim);
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "Catched 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_RecordTime) );
+  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));
 
   CHECK_OCL_ERR( clErr );
 
   // execute the filter on a 3D NDRange
   this->ExecuteKernel( m_PixelCalculation, 3);
   
   // signalize the GPU-side data changed
   m_Output->Modified( GPU_DATA );
 }
 
 us::Module *mitk::PhotoacousticOCLBeamformer::GetModule()
 {
   return us::GetModuleContext()->GetModule();
 }
 
 bool mitk::PhotoacousticOCLBeamformer::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::PhotoacousticOCLBeamformer::SetInput(mitk::Image::Pointer image)
 {
   if(image->GetDimension() != 3)
   {
     mitkThrowException(mitk::Exception) << "Input for " << this->GetNameOfClass() <<
                                            " is not 3D. The filter only supports 3D. Please change your input.";
   }
   OclImageToImageFilter::SetInput(image);
 }
 
 mitk::Image::Pointer mitk::PhotoacousticOCLBeamformer::GetOutput()
 {
   if (m_Output->IsModified(GPU_DATA))
   {
     void* pData = m_Output->TransferDataToCPU(m_CommandQue);
 
     const unsigned int dimension = 3;
     unsigned int* dimensions = m_OutputDim;
 
     const mitk::SlicedGeometry3D::Pointer p_slg = m_Input->GetMITKImage()->GetSlicedGeometry();
 
     MITK_DEBUG << "Creating new MITK Image.";
 
     m_Output->GetMITKImage()->Initialize(this->GetOutputType(), dimension, dimensions);
     m_Output->GetMITKImage()->SetSpacing(p_slg->GetSpacing());
     m_Output->GetMITKImage()->SetGeometry(m_Input->GetMITKImage()->GetGeometry());
     m_Output->GetMITKImage()->SetImportVolume(pData, 0, 0, mitk::Image::ReferenceMemory);
   }
 
   MITK_DEBUG << "Image Initialized.";
 
   return m_Output->GetMITKImage();
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.h b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.h
index 48167d1bb7..9a7c90e0de 100644
--- a/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.h
+++ b/Modules/PhotoacousticsAlgorithms/Algorithms/OCL/mitkPhotoacousticOCLBeamformer.h
@@ -1,129 +1,129 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _MITKPHOTOACOUSTICSOCLBEAMFORMER_H_
 #define _MITKPHOTOACOUSTICSOCLBEAMFORMER_H_
 
 #include "mitkOclImageToImageFilter.h"
 #include <itkObject.h>
 
 namespace mitk
 {
 class OclImageToImageFilter;
 
 /** Documentation
   *
   * \brief The OclBinaryThresholdImageFilter computes a binary segmentation based on given
   threshold values.
 
   *
   * The filter requires two threshold values ( the upper and the lower threshold ) and two image values ( inside and outside ). The resulting voxel of the segmentation image is assigned the inside value 1 if the image value is between the given thresholds and the outside value otherwise.
   */
 
 
 class PhotoacousticOCLBeamformer : public OclImageToImageFilter, public itk::Object
 {
 
 public:
   mitkClassMacroItkParent(PhotoacousticOCLBeamformer, itk::Object);
   itkNewMacro(Self);
 
   /**
   * @brief SetInput Set the input image. Only 3D images are supported for now.
   * @param image a 3D image.
   * @throw mitk::Exception if the dimesion is not 3.
   */
   void SetInput(Image::Pointer image);
 
   mitk::Image::Pointer GetOutput();
 
   /** Update the filter */
   void Update();
   
   void SetOutputDim( unsigned int outputDim[3])
   {
 	  m_OutputDim[0] = outputDim[0];
 	  m_OutputDim[1] = outputDim[1];
     m_OutputDim[2] = outputDim[2];
   }
 
   void SetApodisation(float* apodisation, unsigned short apodArraySize)
   {
     m_ApodArraySize = apodArraySize;
     m_Apodisation = apodisation;
   }
 
   enum BeamformingAlgorithm { DASQuad, DMASQuad, DASSphe, DMASSphe };
 
   void SetAlgorithm(BeamformingAlgorithm algorithm, bool PA)
   {
     m_Algorithm = algorithm;
     m_PAImage = PA;
   }
 
-  void SetBeamformingParameters(float SpeedOfSound, float RecordTime, float Pitch, float Angle, bool PAImage, unsigned short transducerElements)
+  void SetBeamformingParameters(float SpeedOfSound, float timeSpacing, float Pitch, float Angle, bool PAImage, unsigned short transducerElements)
   {
     m_SpeedOfSound = SpeedOfSound;
-    m_RecordTime = RecordTime;
+    m_TimeSpacing = timeSpacing;
     m_Pitch = Pitch;
     m_Angle = Angle;
     m_PAImage = PAImage;
     m_TransducerElements = transducerElements;
   }
 
 protected:
 
   /** Constructor */
   PhotoacousticOCLBeamformer();
 
   /** Destructor */
   virtual ~PhotoacousticOCLBeamformer();
 
   /** Initialize the filter */
   bool Initialize();
 
   void Execute();
 
   mitk::PixelType GetOutputType()
   {
     return mitk::MakeScalarPixelType<float>();
   }
 
   int GetBytesPerElem()
   {
     return sizeof(float);
   }
 
   virtual us::Module* GetModule();
 
 
 private:
   /** The OpenCL kernel for the filter */
   cl_kernel m_PixelCalculation;
 
   unsigned int m_OutputDim[3];
   float* m_Apodisation;
   unsigned short m_ApodArraySize;
   BeamformingAlgorithm m_Algorithm;
   unsigned short m_PAImage;
   float m_SpeedOfSound;
-  float m_RecordTime;
+  float m_TimeSpacing;
   float m_Pitch;
   float m_Angle;
   unsigned short m_TransducerElements;
 };
 }
 #endif
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.cpp b/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.cpp
index 9954db64be..edb5ba55ce 100644
--- a/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.cpp
@@ -1,631 +1,626 @@
 /*===================================================================
 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.
 
 ===================================================================*/
 
 #define _USE_MATH_DEFINES
 
 #include "mitkPhotoacousticBeamformingFilter.h"
 #include "mitkProperties.h"
 #include "mitkImageReadAccessor.h"
 #include <algorithm>
 #include <itkImageIOBase.h>
 #include <chrono>
 #include <cmath>
 #include <thread>
 #include <itkImageIOBase.h>
 #include "mitkImageCast.h"
 #include <mitkPhotoacousticOCLBeamformer.h>
 
 
 mitk::BeamformingFilter::BeamformingFilter() : m_OutputData(nullptr), m_InputData(nullptr)
 {
   this->SetNumberOfIndexedInputs(1);
   this->SetNumberOfRequiredInputs(1);
 
   m_ProgressHandle = [](int, std::string) {};
 }
 
 void mitk::BeamformingFilter::SetProgressHandle(std::function<void(int, std::string)> progressHandle)
 {
   m_ProgressHandle = progressHandle;
 }
 
 mitk::BeamformingFilter::~BeamformingFilter()
 {
 }
 
 void mitk::BeamformingFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* output = this->GetOutput();
   mitk::Image* input = const_cast<mitk::Image *> (this->GetInput());
   if (!output->IsInitialized())
   {
     return;
   }
 
   input->SetRequestedRegionToLargestPossibleRegion();
 
   //GenerateTimeInInputRegion(output, input);
 }
 
 void mitk::BeamformingFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<< "GenerateOutputInformation()");
 
   unsigned int dim[] = { m_Conf.ReconstructionLines, m_Conf.SamplesPerLine, input->GetDimension(2) };
   output->Initialize(mitk::MakeScalarPixelType<float>(), 3, dim);
 
   mitk::Vector3D spacing;
   spacing[0] = m_Conf.Pitch * m_Conf.TransducerElements * 1000 / m_Conf.ReconstructionLines;
-  spacing[1] = m_Conf.RecordTime * m_Conf.SpeedOfSound * 1000 / m_Conf.SamplesPerLine;
+  spacing[1] = m_Conf.RecordTime / 2 * m_Conf.SpeedOfSound * 1000 / m_Conf.SamplesPerLine;
   spacing[2] = 1;
 
   output->GetGeometry()->SetSpacing(spacing);
   output->GetGeometry()->Modified();
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::BeamformingFilter::GenerateData()
 {
   GenerateOutputInformation();
   mitk::Image::Pointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if (!output->IsInitialized())
     return;
 
-  float inputDim[2] = { input->GetDimension(0), input->GetDimension(1) / ((int)m_Conf.Photoacoustic + 1) };
-  // if the photoacoustic option is used, we halve the image, as only the upper part of it contains any information
+  float inputDim[2] = { input->GetDimension(0), input->GetDimension(1) };
   float outputDim[2] = { output->GetDimension(0), output->GetDimension(1) };
 
   unsigned short chunkSize = 5; // TODO: make this slightly less random
 
   unsigned int oclOutputDim[3] = { output->GetDimension(0), output->GetDimension(1), output->GetDimension(2) };
 
   unsigned int oclOutputDimChunk[3] = { output->GetDimension(0), output->GetDimension(1), chunkSize};
   unsigned int oclInputDimChunk[3] = { input->GetDimension(0), input->GetDimension(1), chunkSize};
 
   unsigned int oclOutputDimLastChunk[3] = { output->GetDimension(0), output->GetDimension(1), input->GetDimension(2) % chunkSize };
   unsigned int oclInputDimLastChunk[3] = { input->GetDimension(0), input->GetDimension(1), input->GetDimension(2) % chunkSize };
 
   const int apodArraySize = m_Conf.TransducerElements * 4; // set the resolution of the apodization array
   float* ApodWindow;
 
   // calculate the appropiate apodization window
   switch (m_Conf.Apod)
   {
   case beamformingSettings::Apodization::Hann:
     ApodWindow = VonHannFunction(apodArraySize);
     break;
   case beamformingSettings::Apodization::Hamm:
     ApodWindow = HammFunction(apodArraySize);
     break;
   case beamformingSettings::Apodization::Box:
     ApodWindow = BoxFunction(apodArraySize);
     break;
   default:
     ApodWindow = BoxFunction(apodArraySize);
     break;
   }
 
   int progInterval = output->GetDimension(2) / 20 > 1 ? output->GetDimension(2) / 20 : 1;
   // the interval at which we update the gui progress bar
 
   auto begin = std::chrono::high_resolution_clock::now(); // debbuging the performance...
   if (!m_Conf.UseGPU)
   {
     for (int i = 0; i < output->GetDimension(2); ++i) // seperate Slices should get Beamforming seperately applied
     {
       mitk::ImageReadAccessor inputReadAccessor(input, input->GetSliceData(i));
 
       m_OutputData = new float[m_Conf.ReconstructionLines*m_Conf.SamplesPerLine];
       m_InputDataPuffer = new float[input->GetDimension(0)*input->GetDimension(1)];
 
       // first, we convert any data to float, which we use by default
       if (input->GetPixelType().GetTypeAsString() == "scalar (float)" || input->GetPixelType().GetTypeAsString() == " (float)")
       {
         m_InputData = (float*)inputReadAccessor.GetData();
       }
       else
       {
         MITK_INFO << "Pixel type is not float, abort";
         return;
       }
 
       // fill the image with zeros
       for (int l = 0; l < outputDim[0]; ++l)
       {
         for (int s = 0; s < outputDim[1]; ++s)
         {
           m_OutputData[l*(short)outputDim[1] + s] = 0;
         }
       }
 
       std::thread *threads = new std::thread[(short)outputDim[0]];
 
       // every line will be beamformed in a seperate thread
       if (m_Conf.Algorithm == beamformingSettings::BeamformingAlgorithm::DAS)
       {
         if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::QuadApprox)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingFilter::DASQuadraticLine, this, m_InputData, m_OutputData, inputDim, outputDim, line, ApodWindow, apodArraySize);
           }
         }
         else if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::Spherical)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingFilter::DASSphericalLine, this, m_InputData, m_OutputData, inputDim, outputDim, line, ApodWindow, apodArraySize);
           }
         }
       }
       else if (m_Conf.Algorithm == beamformingSettings::BeamformingAlgorithm::DMAS)
       {
         if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::QuadApprox)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingFilter::DMASQuadraticLine, this, m_InputData, m_OutputData, inputDim, outputDim, line, ApodWindow, apodArraySize);
           }
         }
         else if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::Spherical)
         {
           for (short line = 0; line < outputDim[0]; ++line)
           {
             threads[line] = std::thread(&BeamformingFilter::DMASSphericalLine, this, m_InputData, m_OutputData, inputDim, outputDim, line, ApodWindow, apodArraySize);
           }
         }
       }
       // wait for all lines to finish
       for (short line = 0; line < outputDim[0]; ++line)
       {
         threads[line].join();
       }
 
       output->SetSlice(m_OutputData, i);
 
       if (i % progInterval == 0)
         m_ProgressHandle((int)((i + 1) / (float)output->GetDimension(2) * 100), "performing reconstruction");
 
       delete[] m_OutputData;
       delete[] m_InputDataPuffer;
       m_OutputData = nullptr;
       m_InputData = nullptr;
     }
   }
   else
   {
     mitk::PhotoacousticOCLBeamformer::Pointer m_oclFilter = mitk::PhotoacousticOCLBeamformer::New();
 
     try
     {
       if (m_Conf.Algorithm == beamformingSettings::BeamformingAlgorithm::DAS)
       {
         if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::QuadApprox)
           m_oclFilter->SetAlgorithm(PhotoacousticOCLBeamformer::BeamformingAlgorithm::DASQuad, true);
         else if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::Spherical)
           m_oclFilter->SetAlgorithm(PhotoacousticOCLBeamformer::BeamformingAlgorithm::DASSphe, true);
       }
       else if (m_Conf.Algorithm == beamformingSettings::BeamformingAlgorithm::DMAS)
       {
         if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::QuadApprox)
           m_oclFilter->SetAlgorithm(PhotoacousticOCLBeamformer::BeamformingAlgorithm::DMASQuad, true);
         else if (m_Conf.DelayCalculationMethod == beamformingSettings::DelayCalc::Spherical)
           m_oclFilter->SetAlgorithm(PhotoacousticOCLBeamformer::BeamformingAlgorithm::DMASSphe, true);
       }
       m_oclFilter->SetApodisation(ApodWindow, apodArraySize);
       m_oclFilter->SetOutputDim(oclOutputDimChunk);
-      m_oclFilter->SetBeamformingParameters(m_Conf.SpeedOfSound, m_Conf.RecordTime, m_Conf.Pitch, m_Conf.Angle, m_Conf.Photoacoustic, m_Conf.TransducerElements);
+      m_oclFilter->SetBeamformingParameters(m_Conf.SpeedOfSound, m_Conf.TimeSpacing, m_Conf.Pitch, m_Conf.Angle, m_Conf.Photoacoustic, m_Conf.TransducerElements);
       
       if (chunkSize < oclOutputDim[2])
       {
         bool skip = false;
         for (int i = 0; !skip && i < ceil((float)oclOutputDim[2] / (float)chunkSize); ++i)
         {
-          m_ProgressHandle(100 * ((float)(i * chunkSize) / (float)oclOutputDim[2]), "beamforming");
+          m_ProgressHandle(100 * ((float)(i * chunkSize) / (float)oclOutputDim[2]), "performing reconstruction");
           mitk::Image::Pointer chunk = mitk::Image::New();
           if ((oclOutputDim[2]) - (i * chunkSize) == 1 + chunkSize)
           {
             // A 3d image of 3rd dimension == 1 can not be processed by openCL, make sure that this case never arises
             oclInputDimLastChunk[2] = input->GetDimension(2) % chunkSize + chunkSize;
             oclOutputDimLastChunk[2] = input->GetDimension(2) % chunkSize + chunkSize;
             
             chunk->Initialize(input->GetPixelType(), 3, oclInputDimLastChunk);
             m_oclFilter->SetOutputDim(oclOutputDimLastChunk);
             skip = true; //skip the last chunk
           }
           else if ((oclOutputDim[2]) - (i * chunkSize) >= chunkSize)
             chunk->Initialize(input->GetPixelType(), 3, oclInputDimChunk);
           else
           {
             chunk->Initialize(input->GetPixelType(), 3, oclInputDimLastChunk);
             m_oclFilter->SetOutputDim(oclOutputDimLastChunk);
           }
 
           chunk->SetSpacing(input->GetGeometry()->GetSpacing());
 
           mitk::ImageReadAccessor ChunkMove(input);
           chunk->SetImportVolume((void*)&(((float*)const_cast<void*>(ChunkMove.GetData()))[i * chunkSize * input->GetDimension(0) * input->GetDimension(1)]), 0, 0, mitk::Image::ReferenceMemory);
 
           m_oclFilter->SetInput(chunk);
           m_oclFilter->Update();
           auto out = m_oclFilter->GetOutput();
 
           for (int s = i * chunkSize; s < oclOutputDim[2]; ++s)  // TODO: make the bounds here smaller...
           {
             mitk::ImageReadAccessor copy(out, out->GetSliceData(s - i * chunkSize));
             output->SetImportSlice(const_cast<void*>(copy.GetData()), s, 0, 0, mitk::Image::ReferenceMemory);
           }
         }
       }
       else
       {
-        m_ProgressHandle(50, "beamforming");
+        m_ProgressHandle(50, "performing reconstruction");
 
         m_oclFilter->SetOutputDim(oclOutputDim);
         m_oclFilter->SetInput(input);
         m_oclFilter->Update();
 
         auto out = m_oclFilter->GetOutput();
         mitk::ImageReadAccessor copy(out);
         output->SetImportVolume(const_cast<void*>(copy.GetData()), 0, 0, mitk::Image::ReferenceMemory);
       }
     }
     catch (mitk::Exception &e)
     {
       std::string errorMessage = "Caught unexpected exception ";
       errorMessage.append(e.what());
       MITK_ERROR << errorMessage;
     }
   }
 
   m_TimeOfHeaderInitialization.Modified();
 
   auto end = std::chrono::high_resolution_clock::now();
   MITK_INFO << "Beamforming of " << output->GetDimension(2) << " Images completed in " << ((float)std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count()) / 1000000 << "ms" << std::endl;
 }
 
 void mitk::BeamformingFilter::Configure(beamformingSettings settings)
 {
   m_Conf = settings;
 }
 
 float* mitk::BeamformingFilter::VonHannFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = (1 - cos(2 * M_PI * n / (samples - 1))) / 2;
   }
 
   return ApodWindow;
 }
 
 float* mitk::BeamformingFilter::HammFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = 0.54 - 0.46*cos(2 * M_PI*n / (samples - 1));
   }
 
   return ApodWindow;
 }
 
 float* mitk::BeamformingFilter::BoxFunction(int samples)
 {
   float* ApodWindow = new float[samples];
 
   for (int n = 0; n < samples; ++n)
   {
     ApodWindow[n] = 1;
   }
 
   return ApodWindow;
 }
 
 void mitk::BeamformingFilter::DASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize)
 {
   float& inputS = inputDim[1];
-  float inputSBack = inputS / (2 - m_Conf.Photoacoustic);
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample = 0;
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float l = 0;
   float x = 0;
   float root = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(m_Conf.Angle / 360 * 2 * M_PI);
-  float part_multiplicator = tan_phi * m_Conf.RecordTime / inputSBack * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
+  float part_multiplicator = tan_phi * m_Conf.TimeSpacing * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
   float apod_mult = 1;
 
   float mult = 0;
   short usedLines = (maxLine - minLine);
 
   //quadratic delay
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
-    s_i = sample / outputS * inputS;
+    s_i = (float)sample / outputS * inputS / 2;
 
-    part = part_multiplicator*s_i / (2 - m_Conf.Photoacoustic);
+    part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = apodArraySize / (maxLine - minLine);
 
-    delayMultiplicator = pow((inputSBack / (m_Conf.RecordTime*m_Conf.SpeedOfSound) * (m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2) / s_i / 2;
+    delayMultiplicator = pow((1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * (m_Conf.Pitch*m_Conf.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 - m_Conf.Photoacoustic)*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::BeamformingFilter::DASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize)
 {
   float& inputS = inputDim[1];
-  float inputSBack = inputS / (2 - m_Conf.Photoacoustic);
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample = 0;
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(m_Conf.Angle / 360 * 2 * M_PI);
-  float part_multiplicator = tan_phi * m_Conf.RecordTime / inputSBack * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
+  float part_multiplicator = tan_phi * m_Conf.TimeSpacing * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
   float apod_mult = 1;
 
   short usedLines = (maxLine - minLine);
 
   //exact delay
 
   l_i = (float)line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
-    s_i = (float)sample / outputS * inputS / (2 - m_Conf.Photoacoustic);
+    s_i = (float)sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = apodArraySize / (maxLine - minLine);
 
     for (short l_s = minLine; l_s < maxLine; ++l_s)
     {
       AddSample = (int)sqrt(
         pow(s_i, 2)
         +
-        pow((inputSBack / (m_Conf.RecordTime*m_Conf.SpeedOfSound) * ((l_s - l_i)*m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2)
+        pow((1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * ((l_s - l_i)*m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2)
       ) + (1 - m_Conf.Photoacoustic)*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::BeamformingFilter::DMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize)
 {
   float& inputS = inputDim[1];
-  float inputSBack = inputS / (2 - m_Conf.Photoacoustic);
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample1 = 0;
   short AddSample2 = 0;
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float l = 0;
   float x = 0;
   float root = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(m_Conf.Angle / 360 * 2 * M_PI);
-  float part_multiplicator = tan_phi * m_Conf.RecordTime / inputSBack * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
+  float part_multiplicator = tan_phi * m_Conf.TimeSpacing * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
   float apod_mult = 1;
 
   float mult = 0;
   short usedLines = (maxLine - minLine);
 
   //quadratic delay
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
-    s_i = sample / outputS * inputS / (2 - m_Conf.Photoacoustic);
+    s_i = sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = apodArraySize / (maxLine - minLine);
 
-    delayMultiplicator = pow((inputSBack / (m_Conf.RecordTime*m_Conf.SpeedOfSound) * (m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2) / s_i / 2;
+    delayMultiplicator = pow((1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * (m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2) / s_i / 2;
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)(delayMultiplicator * pow((minLine + l_s - l_i), 2) + s_i) + (1 - m_Conf.Photoacoustic)*s_i;
     }
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       if (AddSample[l_s1 - minLine] < (short)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)
           {
             mult = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL] * apodisation[(short)((l_s2 - minLine)*apod_mult)] * input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL] * apodisation[(short)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(abs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = 10 * output[sample*(short)outputL + line] / (pow(usedLines, 2) - (usedLines - 1));
 
     delete[] AddSample;
   }
 }
 
 void mitk::BeamformingFilter::DMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize)
 {
   float& inputS = inputDim[1];
-  float inputSBack = inputS / (2 - m_Conf.Photoacoustic);
   float& inputL = inputDim[0];
 
   float& outputS = outputDim[1];
   float& outputL = outputDim[0];
 
   short AddSample1 = 0;
   short AddSample2 = 0;
   short maxLine = 0;
   short minLine = 0;
   float delayMultiplicator = 0;
   float l_i = 0;
   float s_i = 0;
 
   float l = 0;
   float x = 0;
   float root = 0;
 
   float part = 0.07 * inputL;
   float tan_phi = std::tan(m_Conf.Angle / 360 * 2 * M_PI);
-  float part_multiplicator = tan_phi * m_Conf.RecordTime / inputSBack * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
+  float part_multiplicator = tan_phi * m_Conf.TimeSpacing * m_Conf.SpeedOfSound / m_Conf.Pitch * m_Conf.ReconstructionLines / m_Conf.TransducerElements;
   float apod_mult = 1;
 
   float mult = 0;
 
   short usedLines = (maxLine - minLine);
 
   //exact delay
 
   l_i = line / outputL * inputL;
 
   for (short sample = 0; sample < outputS; ++sample)
   {
-    s_i = sample / outputS * inputS / (2 - m_Conf.Photoacoustic);
+    s_i = sample / outputS * inputS / 2;
 
     part = part_multiplicator*s_i;
 
     if (part < 1)
       part = 1;
 
     maxLine = (short)std::min((l_i + part) + 1, inputL);
     minLine = (short)std::max((l_i - part), 0.0f);
     usedLines = (maxLine - minLine);
 
     apod_mult = apodArraySize / (maxLine - minLine);
 
     //calculate the AddSamples beforehand to save some time
     short* AddSample = new short[maxLine - minLine];
     for (short l_s = 0; l_s < maxLine - minLine; ++l_s)
     {
       AddSample[l_s] = (short)sqrt(
         pow(s_i, 2)
         +
-        pow((inputSBack / (m_Conf.RecordTime*m_Conf.SpeedOfSound) * ((minLine + l_s - l_i)*m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2)
+        pow((1 / (m_Conf.TimeSpacing*m_Conf.SpeedOfSound) * ((minLine + l_s - l_i)*m_Conf.Pitch*m_Conf.TransducerElements) / inputL), 2)
       ) + (1 - m_Conf.Photoacoustic)*s_i;
     }
 
     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)
           {
             mult = input[l_s2 + AddSample[l_s2 - minLine] * (short)inputL] * apodisation[(int)((l_s2 - minLine)*apod_mult)] * input[l_s1 + AddSample[l_s1 - minLine] * (short)inputL] * apodisation[(int)((l_s1 - minLine)*apod_mult)];
             output[sample*(short)outputL + line] += sqrt(abs(mult)) * ((mult > 0) - (mult < 0));
           }
         }
       }
       else
         --usedLines;
     }
 
     output[sample*(short)outputL + line] = 10 * output[sample*(short)outputL + line] / (pow(usedLines, 2) - (usedLines - 1));
 
     delete[] AddSample;
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.h b/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.h
index 963e64025e..83989f557d 100644
--- a/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.h
+++ b/Modules/PhotoacousticsAlgorithms/Algorithms/mitkPhotoacousticBeamformingFilter.h
@@ -1,108 +1,109 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
 #define MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
 
 #include "mitkImageToImageFilter.h"
 #include <functional>
 
 namespace mitk {
 
   //##Documentation
   //## @brief
   //## @ingroup Process
   class BeamformingFilter : public ImageToImageFilter
   {
   public:
     mitkClassMacro(BeamformingFilter, ImageToImageFilter);
 
     itkFactorylessNewMacro(Self)
       itkCloneMacro(Self)
 
     struct beamformingSettings
     {
       float Pitch = 0.0003; // [m]
       float SpeedOfSound = 1540; // [m/s]
       unsigned int SamplesPerLine = 2048;
       unsigned int ReconstructionLines = 128;
       float RecordTime = 0.00006; // [s]
+      float TimeSpacing = 0.0000000000001; // [s]
       unsigned int TransducerElements = 128;
       bool partial = false;
       unsigned int CropBounds[2] = { 0,0 };
 
       bool UseGPU = true;
 
       enum DelayCalc {QuadApprox, Spherical};
       DelayCalc DelayCalculationMethod = QuadApprox;
 
       enum Apodization {Hamm, Hann, Box};
       Apodization Apod = Hann;
 
       enum BeamformingAlgorithm {DMAS, DAS};
       BeamformingAlgorithm Algorithm = DAS;
 
       float Angle = 10;
       bool Photoacoustic = true;
       float BPHighPass = 50;
       float BPLowPass = 50;
       bool UseBP = false;
       unsigned int ButterworthOrder = 8;
     };
 
     void Configure(beamformingSettings settings);
 
     void SetProgressHandle(std::function<void(int, std::string)> progressHandle);
 
   protected:
 
     BeamformingFilter();
 
     ~BeamformingFilter();
 
     virtual void GenerateInputRequestedRegion() override;
 
     virtual void GenerateOutputInformation() override;
 
     virtual void GenerateData() override;
 
     //##Description
     //## @brief Time when Header was last initialized
     itk::TimeStamp m_TimeOfHeaderInitialization;
 
     std::function<void(int, std::string)> m_ProgressHandle;
 
     float* VonHannFunction(int samples);
     float* HammFunction(int samples);
     float* BoxFunction(int samples);
 
     void DASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize);
     void DASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize);
 
     void DMASQuadraticLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize);
     void DMASSphericalLine(float* input, float* output, float inputDim[2], float outputDim[2], const short& line, float* apodisation, const short& apodArraySize);
 
     float* m_OutputData;
     float* m_InputData;
     float* m_InputDataPuffer;
 
     beamformingSettings m_Conf;
   };
 
 } // namespace mitk
 
 #endif MITK_PHOTOACOUSTICS_BEAMFORMING_FILTER
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl b/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
index c5e43fbc74..8afda8ff42 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DASQuadratic.cl
@@ -1,77 +1,76 @@
 /*===================================================================
 
 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(
   __read_only image3d_t dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
-  float RecordTime,
+  float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements  // 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);
   
   // get image width and weight
   const unsigned int inputL = get_image_width( dSource );
-  const unsigned int inputS = get_image_height( dSource ) / (PAImage + 1);
-  const unsigned int inputSBack = get_image_height( dSource ) / 2;
+  const unsigned int inputS = get_image_height( dSource );
   const unsigned int Slices = get_image_depth( dSource );
 
   // 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 - PAImage);
+    float s_i = (float)globalPosY / outputS * inputS / 2;
 	
-    float part = (tan(Angle / 360 * 2 * M_PI) * RecordTime / inputSBack * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
+    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(inputSBack / (RecordTime*SpeedOfSound) * Pitch * TransducerElements / inputL, 2) / s_i / 2;
+	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)] * read_imagef( dSource, defaultSampler, (int4)(l_s, AddSample, globalPosZ, 0 )).x;
       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 80ca9a93a7..f9a11f7504 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DASspherical.cl
@@ -1,80 +1,79 @@
 /*===================================================================
 
 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(
   __read_only image3d_t dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
-  float RecordTime,
+  float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements  // 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);
   
   // get image width and weight
   const unsigned int inputL = get_image_width( dSource );
-  const unsigned int inputS = get_image_height( dSource ) / (PAImage + 1);
-  const unsigned int inputSBack = get_image_height( dSource ) / 2;
+  const unsigned int inputS = get_image_height( dSource );
   const unsigned int Slices = get_image_depth( dSource );
 
   // 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 - PAImage);
+    float s_i = (float)globalPosY / outputS * inputS / 2;
 
-    float part = (tan(Angle / 360 * 2 * M_PI) * RecordTime / inputSBack * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
+    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((inputSBack / (RecordTime*SpeedOfSound) * ((l_s - l_i)*Pitch*TransducerElements) / inputL), 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)] * read_imagef( dSource, defaultSampler, (int4)(l_s, AddSample, globalPosZ, 0 )).x;
       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 cdcaeeb609..857b988746 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMASQuadratic.cl
@@ -1,93 +1,92 @@
 /*===================================================================
 
 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(
   __read_only image3d_t dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
-  float RecordTime,
+  float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements  // 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);
   
   // get image width and weight
   const unsigned int inputL = get_image_width( dSource );
-  const unsigned int inputS = get_image_height( dSource ) / (PAImage + 1);
-  const unsigned int inputSBack = get_image_height( dSource ) / 2;
+  const unsigned int inputS = get_image_height( dSource );
   const unsigned int Slices = get_image_depth( dSource );
 
   // 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 - PAImage);
+    float s_i = (float)globalPosY / outputS * inputS / 2;
 
-    float part = (tan(Angle / 360 * 2 * M_PI) * RecordTime / inputSBack * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
+    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((inputSBack / (RecordTime*SpeedOfSound) * Pitch * TransducerElements / inputL), 2) / s_i / 2;
+    float delayMultiplicator = pow((1 / (TimeSpacing*SpeedOfSound) * Pitch * TransducerElements / inputL), 2) / s_i / 2;
 	
 	float mult = 0;
 	float output = 0;
 	float AddSample1 = 0;
 	float AddSample2 = 0;
 	
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
       AddSample1 = delayMultiplicator * pow((l_s1 - l_i), 2) + s_i + (1-PAImage)*s_i;
       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 = read_imagef( dSource, defaultSampler, (int4)(l_s2, AddSample2, globalPosZ, 0 )).x
 			* apodArray[(short)((l_s2 - minLine)*apod_mult)]
 			* read_imagef( dSource, defaultSampler, (int4)(l_s1, AddSample1, globalPosZ, 0 )).x 
 			* apodArray[(short)((l_s1 - minLine)*apod_mult)];
             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));
   }
 }
\ No newline at end of file
diff --git a/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl b/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
index b85d294948..fc480b0820 100644
--- a/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
+++ b/Modules/PhotoacousticsAlgorithms/Resources/DMASspherical.cl
@@ -1,99 +1,98 @@
 /*===================================================================
 
 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(
   __read_only image3d_t dSource, // input image
   __global float* dDest, // output buffer
   __global float* apodArray,
   unsigned short apodArraySize,
   float SpeedOfSound,
-  float RecordTime,
+  float TimeSpacing,
   float Pitch,
   float Angle,
   unsigned short PAImage,
   unsigned short TransducerElements  // 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);
   
   // get image width and weight
   const unsigned int inputL = get_image_width( dSource );
-  const unsigned int inputS = get_image_height( dSource ) / (PAImage + 1);
-  const unsigned int inputSBack = get_image_height( dSource ) / 2;
+  const unsigned int inputS = get_image_height( dSource );
   const unsigned int Slices = get_image_depth( dSource );
 
   // 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 - PAImage);
+    float s_i = (float)globalPosY / outputS * inputS / 2;
 
-    float part = (tan(Angle / 360 * 2 * M_PI) * RecordTime / inputSBack * SpeedOfSound / Pitch * outputL / TransducerElements) * s_i;
+    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;
 	float output = 0;
 	float AddSample1 = 0;
 	float AddSample2 = 0;
 
     for (short l_s1 = minLine; l_s1 < maxLine - 1; ++l_s1)
     {
 	  AddSample1 = sqrt(
         pow(s_i, 2)
         +
-        pow((inputSBack / (RecordTime*SpeedOfSound) * ((l_s1 - l_i)*Pitch*TransducerElements)/inputL), 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(
             pow(s_i, 2)
             +
-            pow((inputSBack / (RecordTime*SpeedOfSound) * ((l_s2 - l_i)*Pitch*TransducerElements)/inputL), 2)
+            pow((1 / (TimeSpacing*SpeedOfSound) * ((l_s2 - l_i)*Pitch*TransducerElements)/inputL), 2)
 			) + (1-PAImage)*s_i;
           if (AddSample2 < inputS && AddSample2 >= 0)
           {
             mult = read_imagef( dSource, defaultSampler, (int4)(l_s2, AddSample2, globalPosZ, 0 )).x 
 			* apodArray[(short)((l_s2 - minLine)*apod_mult)] 
 			* read_imagef( dSource, defaultSampler, (int4)(l_s1, AddSample1, globalPosZ, 0 )).x 
 			* apodArray[(short)((l_s1 - minLine)*apod_mult)];
             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));
   }
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
index 207336bf18..471ac2598d 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.imageprocessing/src/internal/PAImageProcessing.cpp
@@ -1,875 +1,877 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "PAImageProcessing.h"
 
 // Qt
 #include <QMessageBox>
 #include <QApplication>
 #include <QMetaType>
 
 //mitk image
 #include <mitkImage.h>
 #include "mitkPhotoacousticImage.h"
 #include "mitkPhotoacousticBeamformingFilter.h"
 
 //other
 #include <thread>
 #include <functional>
 
 const std::string PAImageProcessing::VIEW_ID = "org.mitk.views.paimageprocessing";
 
 PAImageProcessing::PAImageProcessing() : m_ResampleSpacing(0), m_UseLogfilter(false)
 {
   qRegisterMetaType<mitk::Image::Pointer>();
   qRegisterMetaType<std::string>();
 }
 
 void PAImageProcessing::SetFocus()
 {
   m_Controls.buttonApplyBModeFilter->setFocus();
 }
 
 void PAImageProcessing::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.buttonApplyBModeFilter, SIGNAL(clicked()), this, SLOT(StartBmodeThread()));
   connect(m_Controls.DoResampling, SIGNAL(clicked()), this, SLOT(UseResampling()));
   connect(m_Controls.Logfilter, SIGNAL(clicked()), this, SLOT(UseLogfilter()));
   connect(m_Controls.ResamplingValue, SIGNAL(valueChanged(double)), this, SLOT(SetResampling()));
   connect(m_Controls.buttonApplyBeamforming, SIGNAL(clicked()), this, SLOT(StartBeamformingThread()));
   connect(m_Controls.buttonApplyCropFilter, SIGNAL(clicked()), this, SLOT(StartCropThread()));
   connect(m_Controls.buttonApplyBandpass, SIGNAL(clicked()), this, SLOT(StartBandpassThread()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UseImageSpacing()));
   connect(m_Controls.ScanDepth, SIGNAL(valueChanged(double)), this, SLOT(UpdateRecordTime()));
   connect(m_Controls.SpeedOfSound, SIGNAL(valueChanged(double)), this, SLOT(UpdateRecordTime()));
   connect(m_Controls.Samples, SIGNAL(valueChanged(int)), this, SLOT(UpdateRecordTime()));
   connect(m_Controls.UseImageSpacing, SIGNAL(clicked()), this, SLOT(UpdateRecordTime()));
   connect(m_Controls.UseBP, SIGNAL(clicked()), this, SLOT(UseBandpass()));
   connect(m_Controls.boundLow, SIGNAL(valueChanged(int)), this, SLOT(UpdateBounds()));
   connect(m_Controls.boundHigh, SIGNAL(valueChanged(int)), this, SLOT(UpdateBounds()));
   connect(m_Controls.Partial, SIGNAL(clicked()), this, SLOT(UpdateBounds()));
 
   m_Controls.DoResampling->setChecked(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.progressBar->setMinimum(0);
   m_Controls.progressBar->setMaximum(100);
   m_Controls.progressBar->setVisible(false);
   m_Controls.UseImageSpacing->setToolTip("Image spacing of y-Axis must be in us, x-Axis in mm.");
   m_Controls.UseImageSpacing->setToolTipDuration(5000);
   m_Controls.ProgressInfo->setVisible(false);
   m_Controls.UseBP->hide();
 
   UseImageSpacing();
 }
 
 void PAImageProcessing::StartBeamformingThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing beamforming for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.progressBar->setValue(0);
       m_Controls.progressBar->setVisible(true);
       m_Controls.ProgressInfo->setVisible(true);
       m_Controls.ProgressInfo->setText("started");
       m_Controls.buttonApplyBeamforming->setText("working...");
       DisableControls();
 
       BeamformingThread *thread = new BeamformingThread();
       connect(thread, &BeamformingThread::result, this, &PAImageProcessing::HandleBeamformingResults);
       connect(thread, &BeamformingThread::updateProgress, this, &PAImageProcessing::UpdateProgress);
       connect(thread, &BeamformingThread::finished, thread, &QObject::deleteLater);
 
       thread->setConfig(BFconfig);
       thread->setCutoff(m_Controls.Cutoff->value());
       thread->setInputImage(image);
 
       MITK_INFO << "Started new thread for Beamforming";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBeamformingResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
 
   newNodeName << m_OldNodeName << " ";
 
   if (BFconfig.Algorithm == mitk::BeamformingFilter::beamformingSettings::BeamformingAlgorithm::DAS)
     newNodeName << "DAS bf, ";
   else if (BFconfig.Algorithm == mitk::BeamformingFilter::beamformingSettings::BeamformingAlgorithm::DMAS)
     newNodeName << "DMAS bf, ";
 
   if (BFconfig.DelayCalculationMethod == mitk::BeamformingFilter::beamformingSettings::DelayCalc::QuadApprox)
     newNodeName << "q. delay";
   if (BFconfig.DelayCalculationMethod == mitk::BeamformingFilter::beamformingSettings::DelayCalc::Spherical)
     newNodeName << "s. delay";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   // disable progress bar
   m_Controls.progressBar->setVisible(false);
   m_Controls.ProgressInfo->setVisible(false);
   m_Controls.buttonApplyBeamforming->setText("Apply Beamforming");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartBmodeThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing image processing for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyBModeFilter->setText("working...");
       DisableControls();
 
       BmodeThread *thread = new BmodeThread();
       connect(thread, &BmodeThread::result, this, &PAImageProcessing::HandleBmodeResults);
       connect(thread, &BmodeThread::finished, thread, &QObject::deleteLater);
 
       if(m_Controls.BModeMethod->currentText() == "Simple Abs Filter")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticImage::BModeMethod::Abs);
       else if(m_Controls.BModeMethod->currentText() == "Shape Detection")
         thread->setConfig(m_UseLogfilter, m_ResampleSpacing, mitk::PhotoacousticImage::BModeMethod::ShapeDetection);
 
       thread->setInputImage(image);
 
       MITK_INFO << "Started new thread for Image Processing";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBmodeResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "B-Mode";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   // disable progress bar
   m_Controls.progressBar->setVisible(false);
   m_Controls.buttonApplyBModeFilter->setText("Apply B-mode Filter");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartCropThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image cropping.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing image cropping for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyCropFilter->setText("working...");
       DisableControls();
 
       CropThread *thread = new CropThread();
       connect(thread, &CropThread::result, this, &PAImageProcessing::HandleCropResults);
       connect(thread, &CropThread::finished, thread, &QObject::deleteLater);
 
       thread->setConfig(m_Controls.CutoffAbove->value(), m_Controls.CutoffBelow->value());
       thread->setInputImage(image);
 
       MITK_INFO << "Started new thread for Image Cropping";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleCropResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "Cropped";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   m_Controls.buttonApplyCropFilter->setText("Apply Crop Filter");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::StartBandpassThread()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(NULL, "Template", "Please load and select an image before starting image cropping.");
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
     if (image)
     {
       UpdateBFSettings(image);
       std::stringstream message;
       std::string name;
       message << "Performing Bandpass filter on image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
         m_OldNodeName = name;
       }
       else
         m_OldNodeName = " ";
 
       message << ".";
       MITK_INFO << message.str();
 
       m_Controls.buttonApplyBandpass->setText("working...");
       DisableControls();
 
       BandpassThread *thread = new BandpassThread();
       connect(thread, &BandpassThread::result, this, &PAImageProcessing::HandleBandpassResults);
       connect(thread, &BandpassThread::finished, thread, &QObject::deleteLater);
 
       float recordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000 / m_Controls.BPSpeedOfSound->value();
 
       // add a safeguard so the program does not chrash when applying a Bandpass that reaches out of the bounds of the image
       float maxFrequency = 1 / (recordTime / image->GetDimension(1)) * image->GetDimension(1) / 2 / 2 / 1000;
       float BPHighPass = 1000000 * m_Controls.BPhigh->value(); // [Hz]
       float BPLowPass = maxFrequency - 1000000 * m_Controls.BPlow->value(); // [Hz]
 
       if (BPLowPass > maxFrequency && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too low, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPLowPass < 0 && m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("LowPass too high, disabled it.");
         Msgbox.exec();
 
         BPLowPass = 0;
       }
       if (BPHighPass > maxFrequency &&  m_Controls.UseBP->isChecked())
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass too high, disabled it.");
         Msgbox.exec();
 
         BPHighPass = 0;
       }
       if (BPHighPass > maxFrequency - BFconfig.BPLowPass)
       {
         QMessageBox Msgbox;
         Msgbox.setText("HighPass higher than LowPass, disabled both.");
         Msgbox.exec();
 
         BPHighPass = 0;
         BPLowPass = 0;
       }
 
       thread->setConfig(BPHighPass, BPLowPass, m_Controls.BPFalloff->value(), recordTime);
       thread->setInputImage(image);
 
       MITK_INFO << "Started new thread for Bandpass filter";
       thread->start();
     }
   }
 }
 
 void PAImageProcessing::HandleBandpassResults(mitk::Image::Pointer image)
 {
   auto newNode = mitk::DataNode::New();
   newNode->SetData(image);
 
   // name the new Data node
   std::stringstream newNodeName;
   newNodeName << m_OldNodeName << " ";
   newNodeName << "Bandpassed";
 
   newNode->SetName(newNodeName.str());
 
   // update level window for the current dynamic range
   mitk::LevelWindow levelWindow;
   newNode->GetLevelWindow(levelWindow);
   auto data = newNode->GetData();
   levelWindow.SetAuto(dynamic_cast<mitk::Image*>(data), true, true);
   newNode->SetLevelWindow(levelWindow);
 
   // add new node to data storage
   this->GetDataStorage()->Add(newNode);
 
   m_Controls.buttonApplyBandpass->setText("Apply Bandpass");
   EnableControls();
 
   // update rendering
   mitk::RenderingManager::GetInstance()->InitializeViews(
     dynamic_cast<mitk::Image*>(data)->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void PAImageProcessing::UpdateBounds()
 {
   if (!m_Controls.Partial->isChecked())
   {
     m_Controls.boundLow->setEnabled(false);
     m_Controls.boundHigh->setEnabled(false);
     BFconfig.partial = false;
     return;
   }
   else
   {
     m_Controls.boundLow->setEnabled(true);
     m_Controls.boundHigh->setEnabled(true);
     BFconfig.partial = true;
   }
 
   if(m_Controls.boundLow->value()>m_Controls.boundHigh->value())
   {
     MITK_INFO << "high bound < low bound -> setting both to beamform only first slice";
     m_Controls.boundLow->setValue(0); 
     m_Controls.boundHigh->setValue(0);
     BFconfig.CropBounds[0] = 0;
     BFconfig.CropBounds[1] = 0;
   }
   else
   {
     BFconfig.CropBounds[0] = m_Controls.boundLow->value();
     BFconfig.CropBounds[1] = m_Controls.boundHigh->value();
   }
 }
 
 void PAImageProcessing::UpdateProgress(int progress, std::string progressInfo)
 {
   if (progress < 100)
     m_Controls.progressBar->setValue(progress);
   else
     m_Controls.progressBar->setValue(100);
   m_Controls.ProgressInfo->setText(progressInfo.c_str());
   qApp->processEvents();
 }
 
 void PAImageProcessing::UpdateImageInfo()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode::Pointer node = nodes.front();
 
   if (!node)
   {
     // Nothing selected
     return;
   }
 
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>(data);
 
     if (image)
     {
       // beamforming configs
       if (m_Controls.UseImageSpacing->isChecked())
       {
         m_Controls.ElementCount->setValue(image->GetDimension(0));
         m_Controls.Pitch->setValue(image->GetGeometry()->GetSpacing()[0]);
         m_Controls.boundLow->setMaximum(image->GetDimension(2) - 1);
       }
       UpdateRecordTime(image);
 
       // bandpass configs
       float speedOfSound = m_Controls.BPSpeedOfSound->value(); // [m/s]
       float recordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000 / speedOfSound;
 
       std::stringstream frequency;
       float maxFrequency = 1 / (recordTime / image->GetDimension(1)) * image->GetDimension(1) / 2 / 2 / 1000;
       frequency << maxFrequency / 1000000; //[MHz]
       frequency << "MHz";
 
       m_Controls.BPhigh->setMaximum(maxFrequency / 1000000);
       m_Controls.BPlow->setMaximum(maxFrequency / 1000000);
 
       frequency << " is the maximal allowed frequency for the selected image.";
       m_Controls.BPhigh->setToolTip(frequency.str().c_str());
       m_Controls.BPlow->setToolTip(frequency.str().c_str());
       m_Controls.BPhigh->setToolTipDuration(5000);
       m_Controls.BPlow->setToolTipDuration(5000);
     }
   }
 }
 
 void PAImageProcessing::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
                                              const QList<mitk::DataNode::Pointer>& nodes )
 {
   // iterate all selected objects, adjust warning visibility
   foreach( mitk::DataNode::Pointer node, nodes )
   {
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       m_Controls.labelWarning->setVisible( false );
       m_Controls.buttonApplyBModeFilter->setEnabled( true );
       m_Controls.labelWarning2->setVisible(false);
       m_Controls.buttonApplyCropFilter->setEnabled(true);
       m_Controls.labelWarning3->setVisible(false);
       m_Controls.buttonApplyBandpass->setEnabled(true);
       UpdateImageInfo();
       return;
     }
   }
   m_Controls.labelWarning->setVisible( true );
   m_Controls.buttonApplyBModeFilter->setEnabled( false );
   m_Controls.labelWarning2->setVisible(true);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
   m_Controls.labelWarning3->setVisible(true);
   m_Controls.buttonApplyBandpass->setEnabled(false);
 }
 
 void PAImageProcessing::UseResampling()
 {
   if (m_Controls.DoResampling->isChecked())
   {
     m_Controls.ResamplingValue->setEnabled(true);
     m_ResampleSpacing = m_Controls.ResamplingValue->value();
   }
   else
   {
     m_Controls.ResamplingValue->setEnabled(false);
     m_ResampleSpacing = 0;
   }
 }
 
 void PAImageProcessing::UseLogfilter()
 {
   m_UseLogfilter = m_Controls.Logfilter->isChecked();
 }
 
 void PAImageProcessing::SetResampling()
 {
   m_ResampleSpacing = m_Controls.ResamplingValue->value();
 }
 
 void PAImageProcessing::UpdateBFSettings(mitk::Image::Pointer image)
 {
   if ("DAS" == m_Controls.BFAlgorithm->currentText())
     BFconfig.Algorithm = mitk::BeamformingFilter::beamformingSettings::BeamformingAlgorithm::DAS;
   else if ("DMAS" == m_Controls.BFAlgorithm->currentText())
     BFconfig.Algorithm = mitk::BeamformingFilter::beamformingSettings::BeamformingAlgorithm::DMAS;
 
   if ("Quad. Approx." == m_Controls.DelayCalculation->currentText())
   {
     BFconfig.DelayCalculationMethod = mitk::BeamformingFilter::beamformingSettings::DelayCalc::QuadApprox;
   }
   else if ("Spherical Wave" == m_Controls.DelayCalculation->currentText())
   {
     BFconfig.DelayCalculationMethod = mitk::BeamformingFilter::beamformingSettings::DelayCalc::Spherical;
   }
 
   if ("Von Hann" == m_Controls.Apodization->currentText())
   {
     BFconfig.Apod = mitk::BeamformingFilter::beamformingSettings::Apodization::Hann;
   }
   else if ("Hamming" == m_Controls.Apodization->currentText())
   {
     BFconfig.Apod = mitk::BeamformingFilter::beamformingSettings::Apodization::Hamm;
   }
   else if ("Box" == m_Controls.Apodization->currentText())
   {
     BFconfig.Apod = mitk::BeamformingFilter::beamformingSettings::Apodization::Box;
   }
 
   BFconfig.Pitch = m_Controls.Pitch->value() / 1000; // [m]
   BFconfig.SpeedOfSound = m_Controls.SpeedOfSound->value(); // [m/s]
   BFconfig.SamplesPerLine = m_Controls.Samples->value();
   BFconfig.ReconstructionLines = m_Controls.Lines->value();
   BFconfig.TransducerElements = m_Controls.ElementCount->value();
   BFconfig.Angle = m_Controls.Angle->value(); // [deg]
   BFconfig.ButterworthOrder = m_Controls.BPFalloff->value();
   BFconfig.UseBP = m_Controls.UseBP->isChecked();
   BFconfig.UseGPU = m_Controls.UseGPU->isChecked();
 
   UpdateRecordTime(image);
   UpdateBounds();
 }
 
 void PAImageProcessing::UpdateRecordTime(mitk::Image::Pointer image)
 {
   if (m_Controls.UseImageSpacing->isChecked())
   {
     BFconfig.RecordTime = image->GetDimension(1)*image->GetGeometry()->GetSpacing()[1] / 1000000; // [s]
+    BFconfig.TimeSpacing = image->GetGeometry()->GetSpacing()[1] / 1000000;
     MITK_INFO << "Calculated Scan Depth of " << BFconfig.RecordTime * BFconfig.SpeedOfSound * 100 << "cm";
   }
   else
   {
-    BFconfig.RecordTime = m_Controls.ScanDepth->value() / 1000 / BFconfig.SpeedOfSound; // [s]
+    BFconfig.RecordTime = 2 * m_Controls.ScanDepth->value() / 1000 / BFconfig.SpeedOfSound; // [s]
+    BFconfig.TimeSpacing = BFconfig.RecordTime / image->GetDimension(1);
   }
 
   if ("US Image" == m_Controls.ImageType->currentText())
   {
     BFconfig.Photoacoustic = false;
   }
   else if ("PA Image" == m_Controls.ImageType->currentText())
   {
     BFconfig.Photoacoustic = true;
   }
 }
 
 void PAImageProcessing::EnableControls()
 {
   m_Controls.DoResampling->setEnabled(true);
   UseResampling();
   m_Controls.Logfilter->setEnabled(true);
   m_Controls.buttonApplyBModeFilter->setEnabled(true);
 
   m_Controls.CutoffAbove->setEnabled(true);
   m_Controls.CutoffBelow->setEnabled(true);
   m_Controls.Cutoff->setEnabled(true);
   m_Controls.buttonApplyCropFilter->setEnabled(true);
 
   m_Controls.buttonApplyBandpass->setEnabled(true);
 
   m_Controls.BFAlgorithm->setEnabled(true);
   m_Controls.DelayCalculation->setEnabled(true);
   m_Controls.ImageType->setEnabled(true);
   m_Controls.Apodization->setEnabled(true);
   m_Controls.UseBP->setEnabled(true);
   m_Controls.UseGPU->setEnabled(true);
   m_Controls.BPhigh->setEnabled(true);
   m_Controls.BPlow->setEnabled(true);
   m_Controls.BPFalloff->setEnabled(true);
   m_Controls.UseImageSpacing->setEnabled(true);
   UseImageSpacing();
   m_Controls.Pitch->setEnabled(true);
   m_Controls.ElementCount->setEnabled(true);
   m_Controls.SpeedOfSound->setEnabled(true);
   m_Controls.Samples->setEnabled(true);
   m_Controls.Lines->setEnabled(true);
   m_Controls.Angle->setEnabled(true);
   m_Controls.buttonApplyBeamforming->setEnabled(true);
 }
 
 void PAImageProcessing::DisableControls()
 {
   m_Controls.DoResampling->setEnabled(false);
   m_Controls.ResamplingValue->setEnabled(false);
   m_Controls.Logfilter->setEnabled(false);
   m_Controls.buttonApplyBModeFilter->setEnabled(false);
 
   m_Controls.CutoffAbove->setEnabled(false);
   m_Controls.CutoffBelow->setEnabled(false);
   m_Controls.Cutoff->setEnabled(false);
   m_Controls.buttonApplyCropFilter->setEnabled(false);
 
   m_Controls.buttonApplyBandpass->setEnabled(false);
 
   m_Controls.BFAlgorithm->setEnabled(false);
   m_Controls.DelayCalculation->setEnabled(false);
   m_Controls.ImageType->setEnabled(false);
   m_Controls.Apodization->setEnabled(false);
   m_Controls.UseBP->setEnabled(false);
   m_Controls.UseGPU->setEnabled(false);
   m_Controls.BPhigh->setEnabled(false);
   m_Controls.BPlow->setEnabled(false);
   m_Controls.BPFalloff->setEnabled(false);
   m_Controls.UseImageSpacing->setEnabled(false);
   m_Controls.ScanDepth->setEnabled(false);
   m_Controls.Pitch->setEnabled(false);
   m_Controls.ElementCount->setEnabled(false);
   m_Controls.SpeedOfSound->setEnabled(false);
   m_Controls.Samples->setEnabled(false);
   m_Controls.Lines->setEnabled(false);
   m_Controls.Angle->setEnabled(false);
   m_Controls.buttonApplyBeamforming->setEnabled(false);
 }
 
 void PAImageProcessing::UseImageSpacing()
 {
   if (m_Controls.UseImageSpacing->isChecked())
   {
     m_Controls.ScanDepth->setDisabled(true);
   }
   else
   {
     m_Controls.ScanDepth->setEnabled(true);
   }
 }
 
 void BeamformingThread::run()
 {
   mitk::Image::Pointer resultImage;
   mitk::PhotoacousticImage::Pointer filterbank = mitk::PhotoacousticImage::New();
   std::function<void(int, std::string)> progressHandle = [this](int progress, std::string progressInfo) {
       emit updateProgress(progress, progressInfo);
     };
 
   resultImage = filterbank->ApplyBeamforming(m_InputImage, m_BFconfig, m_Cutoff, progressHandle);
 
    emit result(resultImage);
 }
 
 void BeamformingThread::setConfig(mitk::BeamformingFilter::beamformingSettings BFconfig)
 {
   m_BFconfig = BFconfig;
 }
 
 void BeamformingThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BeamformingThread::setCutoff(int cutoff)
 {
   m_Cutoff = cutoff;
 }
 
 void BmodeThread::run()
 {
   mitk::Image::Pointer resultImage;
   mitk::PhotoacousticImage::Pointer filterbank = mitk::PhotoacousticImage::New();
 
   resultImage = filterbank->ApplyBmodeFilter(m_InputImage, m_Method, m_UseLogfilter, m_ResampleSpacing);
 
   emit result(resultImage);
 }
 
 void BmodeThread::setConfig(bool useLogfilter, double resampleSpacing, mitk::PhotoacousticImage::BModeMethod method)
 {
   m_UseLogfilter = useLogfilter;
   m_ResampleSpacing = resampleSpacing;
   m_Method = method;
 }
 
 void BmodeThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void CropThread::run()
 {
   mitk::Image::Pointer resultImage;
   mitk::PhotoacousticImage::Pointer filterbank = mitk::PhotoacousticImage::New();
 
   resultImage = filterbank->ApplyCropping(m_InputImage, m_CutAbove, m_CutBelow, 0, 0, 0, m_InputImage->GetDimension(2) - 1);
 
   emit result(resultImage);
 }
 
 void CropThread::setConfig(unsigned int CutAbove, unsigned int CutBelow)
 {
   m_CutAbove = CutAbove;
   m_CutBelow = CutBelow;
 }
 
 void CropThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }
 
 void BandpassThread::run()
 {
   mitk::Image::Pointer resultImage;
   mitk::PhotoacousticImage::Pointer filterbank = mitk::PhotoacousticImage::New();
 
   resultImage = filterbank->BandpassFilter(m_InputImage, m_RecordTime, m_BPHighPass, m_BPLowPass, m_TukeyAlpha);
   MITK_INFO << "lol";
   emit result(resultImage);
 }
 
 void BandpassThread::setConfig(float BPHighPass, float BPLowPass, float TukeyAlpha, float recordTime)
 {
   m_BPHighPass = BPHighPass;
   m_BPLowPass = BPLowPass;
   m_TukeyAlpha = TukeyAlpha;
   m_RecordTime = recordTime;
 }
 
 void BandpassThread::setInputImage(mitk::Image::Pointer image)
 {
   m_InputImage = image;
 }