diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h b/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
index b731e3b10e..db7df823bc 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkPhotoacousticFilterService.h
@@ -1,126 +1,128 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkPhotoacousticFilterService_H_HEADER_INCLUDED
 #define mitkPhotoacousticFilterService_H_HEADER_INCLUDED
 
 #include "itkObject.h"
 #include "mitkCommon.h"
 #include "mitkImage.h"
 #include <functional>
 
 #include "mitkBeamformingSettings.h"
 #include "mitkBeamformingFilter.h"
 #include "MitkPhotoacousticsAlgorithmsExports.h"
 
 namespace mitk {
   /*!
   * \brief Class holding methods to apply all Filters within the Photoacoustics Algorithms Module
   *
   *  Implemented are:
   *  - A B-Mode Filter
   *  - A Resampling Filter
   *  - Beamforming on GPU and CPU
   *  - A Bandpass Filter
   */
 
   class MITKPHOTOACOUSTICSALGORITHMS_EXPORT PhotoacousticFilterService : public itk::Object
   {
   public:
     mitkClassMacroItkParent(mitk::PhotoacousticFilterService, itk::Object);
     itkFactorylessNewMacro(Self);
 
     /** \brief Defines the methods for the B-Mode filter
     * Currently implemented are an Envelope Detection filter and a simple Absolute filter.
     */
     enum BModeMethod { EnvelopeDetection, Abs };
 
     /** \brief Applies a B-Mode Filter
     *
     * Applies a B-Mode filter using the given parameters.
     * @param inputImage The image to be processed.
     * @param method The kind of B-Mode Filter to be used.
     * @param UseLogFilter Setting this to true will apply a simple logarithm to the image after the B-Mode Filter has been applied.
     * @param resampleSpacing If this is set to 0, nothing will be done; otherwise, the image is resampled to a spacing of resampleSpacing mm per pixel.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer ApplyBmodeFilter(mitk::Image::Pointer inputImage,
       BModeMethod method = BModeMethod::Abs,
       bool UseLogFilter = false);
 
     /** \brief Resamples the given image
     *
     * Resamples an image using the given parameters.
     * @param inputImage The image to be processed.
     * @param outputSize An array of dimensions the image should be resampled to.
     * @return The processed image is returned after the filter has finished.
     */
-    mitk::Image::Pointer ApplyResampling(mitk::Image::Pointer inputImage, double outputSpacing[2]);
+    mitk::Image::Pointer ApplyResampling(mitk::Image::Pointer inputImage, double* outputSpacing);
+
+    mitk::Image::Pointer ApplyResamplingToDim(mitk::Image::Pointer inputImage, double* outputDimension);
 
     /** \brief Beamforms the given image
     *
     * Resamples an image using the given parameters.
     * @param inputImage The image to be processed.
     * @param config The configuration set to be used for beamforming.
     * @param progressHandle An std::function<void(int, std::string)>, through which progress of the currently updating filter is reported.
     * The integer argument is a number between 0 an 100 to indicate how far completion has been achieved, the std::string argument indicates what the filter is currently doing.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer ApplyBeamforming(mitk::Image::Pointer inputImage, BeamformingSettings::Pointer config, std::function<void(int, std::string)> progressHandle = [](int, std::string) {});
 
     /** \brief Crops the given image
     *
     * Crops an image in 3 dimension using the given parameters.
     * @param inputImage The image to be processed.
     * @param above How many voxels will be cut from the top of the image.
     * @param below How many voxels will be cut from the bottom of the image.
     * @param right How many voxels will be cut from the right side of the image.
     * @param left How many voxels will be cut from the left side of the image.
     * @param minSlice The first slice to be present in the resulting image.
     * @param maxSlice The last slice to be present in the resulting image.
     * @return The processed image is returned after the filter has finished. For the purposes of this module, the returned image is always of type float.
     */
     mitk::Image::Pointer ApplyCropping(mitk::Image::Pointer inputImage, int above, int below, int right, int left, int minSlice, int maxSlice);
 
     /** \brief Applies a Bandpass filter to the given image
     *
     * Applies a bandpass filter to the given image using the given parameters.
     * @param data The image to be processed.
     * @param BPHighPass The position at which Lower frequencies are completely cut off in Hz.
     * @param BPLowPass The position at which Higher frequencies are completely cut off in Hz.
     * @param alphaHighPass The high pass tukey window parameter to control the shape of the bandpass filter: 0 will make it a Box function, 1 a Hann function. alpha can be set between those two bounds.
     * @param alphaLowPass The low passtukey window parameter to control the shape of the bandpass filter: 0 will make it a Box function, 1 a Hann function. alpha can be set between those two bounds.
     * @return The processed image is returned after the filter has finished.
     */
     mitk::Image::Pointer ApplyBandpassFilter(mitk::Image::Pointer data,
       float BPHighPass, float BPLowPass,
       float alphaHighPass, float alphaLowPass,
       float timeSpacing, float SpeedOfSound, bool IsBFImage);
 
   protected:
     PhotoacousticFilterService();
     ~PhotoacousticFilterService() override;
 
     /** \brief
       For performance reasons, an instance of the Beamforming filter is initialized as soon as possible and kept for all further uses.
     */
     mitk::BeamformingFilter::Pointer m_BeamformingFilter;
 
     mitk::Image::Pointer ConvertToFloat(mitk::Image::Pointer);
   };
 } // namespace mitk
 
 #endif /* mitkPhotoacousticFilterService_H_HEADER_INCLUDED */
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
index f142d14928..d9c711177f 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
@@ -1,269 +1,267 @@
 /*===================================================================
 mitkCastToFloatImageFilter
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include "mitkBandpassFilter.h"
 
 #include "../ITKFilter/ITKUltrasound/itkFFT1DComplexConjugateToRealImageFilter.h"
 #include "../ITKFilter/ITKUltrasound/itkFFT1DRealToComplexConjugateImageFilter.h"
 #include "itkComplexToModulusImageFilter.h"
 #include "itkMultiplyImageFilter.h"
 #include "mitkIOUtil.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageCast.h"
 
 mitk::BandpassFilter::BandpassFilter()
   : m_HighPass(0),
     m_LowPass(50),
     m_HighPassAlpha(1),
     m_LowPassAlpha(1),
     m_FilterService(mitk::PhotoacousticFilterService::New())
 {
   MITK_INFO << "Instantiating BandpassFilter...";
   SetNumberOfIndexedInputs(1);
   SetNumberOfIndexedOutputs(1);
   MITK_INFO << "Instantiating BandpassFilter...[Done]";
 }
 
 mitk::BandpassFilter::~BandpassFilter()
 {
   MITK_INFO << "Destructed BandpassFilter.";
 }
 
 void mitk::BandpassFilter::SanityCheckPreconditions()
 {
   auto input = GetInput();
 
   std::string type = input->GetPixelType().GetTypeAsString();
   if (!(type == "scalar (float)" || type == " (float)"))
   {
     MITK_ERROR << "This filter can currently only handle float type images.";
     mitkThrow() << "This filter can currently only handle float type images.";
   }
   if (m_HighPass > m_LowPass)
   {
     MITK_ERROR << "High Pass is higher than Low Pass; aborting.";
     mitkThrow() << "High Pass is higher than Low Pass; aborting.";
   }
 }
 
 itk::Image<float, 3U>::Pointer BPFunction(mitk::Image::Pointer reference,
                                           float cutoffFrequencyPixelHighPass,
                                           float cutoffFrequencyPixelLowPass,
                                           float alphaHighPass,
                                           float alphaLowPass)
 {
   float *imageData = new float[reference->GetDimension(0) * reference->GetDimension(1)];
 
   float width = cutoffFrequencyPixelLowPass - cutoffFrequencyPixelHighPass;
   float center = cutoffFrequencyPixelHighPass + width / 2.f;
 
   for (unsigned int n = 0; n < reference->GetDimension(1); ++n)
   {
     imageData[reference->GetDimension(0) * n] = 0;
   }
   for (int n = 0; n < width; ++n)
   {
     imageData[reference->GetDimension(0) * (int)(n + center - (width / 2.f))] = 1;
     if (n <= (alphaHighPass * (width - 1)) / 2.f)
     {
       if (alphaHighPass > 0.00001f)
       {
         imageData[reference->GetDimension(0) * (int)(n + center - (width / 2.f))] =
           (1 + cos(itk::Math::pi * (2 * n / (alphaHighPass * (width - 1)) - 1))) / 2;
       }
       else
       {
         imageData[reference->GetDimension(0) * (int)(n + center - (width / 2.f))] = 1;
       }
     }
     else if (n >= (width - 1) * (1 - alphaLowPass / 2.f))
     {
       if (alphaLowPass > 0.00001f)
       {
         imageData[reference->GetDimension(0) * (int)(n + center - (width / 2.f))] =
           (1 + cos(itk::Math::pi * (2 * n / (alphaLowPass * (width - 1)) + 1 - 2 / alphaLowPass))) / 2;
       }
       else
       {
         imageData[reference->GetDimension(0) * (int)(n + center - (width / 2.f))] = 1;
       }
     }
   }
 
   for (unsigned int n = reference->GetDimension(1) / 2; n < reference->GetDimension(1); ++n)
   {
     imageData[reference->GetDimension(0) * n] =
       imageData[(reference->GetDimension(1) - (n + 1)) * reference->GetDimension(0)];
   }
 
   for (unsigned int line = 1; line < reference->GetDimension(0); ++line)
   {
     for (unsigned int sample = 0; sample < reference->GetDimension(1); ++sample)
     {
       imageData[reference->GetDimension(0) * sample + line] = imageData[reference->GetDimension(0) * sample];
     }
   }
 
   typedef itk::Image<float, 3U> ImageType;
   ImageType::RegionType region;
   ImageType::IndexType start;
   start.Fill(0);
 
   region.SetIndex(start);
 
   ImageType::SizeType size;
   size[0] = reference->GetDimension(0);
   size[1] = reference->GetDimension(1);
   size[2] = reference->GetDimension(2);
 
   region.SetSize(size);
 
   ImageType::SpacingType SpacingItk;
   SpacingItk[0] = reference->GetGeometry()->GetSpacing()[0];
   SpacingItk[1] = reference->GetGeometry()->GetSpacing()[1];
   SpacingItk[2] = reference->GetGeometry()->GetSpacing()[2];
 
   ImageType::Pointer image = ImageType::New();
   image->SetRegions(region);
   image->Allocate();
   image->FillBuffer(itk::NumericTraits<float>::Zero);
   image->SetSpacing(SpacingItk);
 
   ImageType::IndexType pixelIndex;
 
   for (unsigned int slice = 0; slice < reference->GetDimension(2); ++slice)
   {
     for (unsigned int line = 0; line < reference->GetDimension(0); ++line)
     {
       for (unsigned int sample = 0; sample < reference->GetDimension(1); ++sample)
       {
         pixelIndex[0] = line;
         pixelIndex[1] = sample;
         pixelIndex[2] = slice;
 
         image->SetPixel(pixelIndex, imageData[line + sample * reference->GetDimension(0)]);
       }
     }
   }
 
   delete[] imageData;
 
   return image;
 }
 
 void mitk::BandpassFilter::GenerateData()
 {
   SanityCheckPreconditions();
   auto input = GetInput();
   auto output = GetOutput();
   mitk::Image::Pointer resampledInput = input;
 
   double powerOfTwo = std::log2(input->GetDimension(1));
   int finalSize = 0;
   double spacingResize = 1;
 
   // check if this is a power of two by checking that log2 is int
   if (std::fmod(powerOfTwo, 1.0) >= std::numeric_limits<double>::epsilon())
   {
     finalSize = (int)pow(2, std::ceil(powerOfTwo));
-    double spacing_x = input->GetGeometry()->GetSpacing()[0];
-    double spacing_y = input->GetGeometry()->GetSpacing()[1] * ((double)input->GetDimensions()[1]) / finalSize;
-    double dim[2] = {spacing_x, spacing_y};
-    resampledInput = m_FilterService->ApplyResampling(input, dim);
+    double dim[2] = {(double)input->GetDimension(0), (double)finalSize };
+    resampledInput = m_FilterService->ApplyResamplingToDim(input, dim);
     spacingResize = (double)input->GetDimension(1) / finalSize;
   }
 
   // do a fourier transform, multiply with an appropriate window for the filter, and transform back
   typedef itk::Image<float, 3> RealImageType;
+  MITK_INFO << resampledInput->GetDimension(0) << " " << resampledInput->GetDimension(1) << " " << resampledInput->GetDimension(2) << "asd" << sizeof(long double);
   RealImageType::Pointer image;
-
   mitk::CastToItkImage(resampledInput, image);
   typedef itk::FFT1DRealToComplexConjugateImageFilter<RealImageType> ForwardFFTFilterType;
   typedef ForwardFFTFilterType::OutputImageType ComplexImageType;
   ForwardFFTFilterType::Pointer forwardFFTFilter = ForwardFFTFilterType::New();
   forwardFFTFilter->SetInput(image);
   forwardFFTFilter->SetDirection(1);
 
   try
   {
     forwardFFTFilter->UpdateOutputInformation();
   }
   catch (itk::ExceptionObject &error)
   {
     std::cerr << "Error: " << error << std::endl;
     MITK_ERROR << "Bandpass could not be applied";
     mitkThrow() << "bandpass error";
   }
 
   if (m_HighPass > m_LowPass)
     mitkThrow() << "High pass frequency higher than low pass frequency, abort";
 
   float singleVoxel = spacingResize / (m_TimeSpacing * resampledInput->GetDimension(1)); // [Hz]
   if(m_IsBFImage)
     singleVoxel = spacingResize / (resampledInput->GetGeometry()->GetSpacing()[1] / 1e3 / m_SpeedOfSound * resampledInput->GetDimension(1)); // [Hz]
   float cutoffPixelHighPass = std::min((m_HighPass / singleVoxel), (float)resampledInput->GetDimension(1) / 2.0f);
   float cutoffPixelLowPass = std::min((m_LowPass / singleVoxel), (float)resampledInput->GetDimension(1) / 2.0f);
 
   MITK_INFO << "SingleVoxel: " << singleVoxel;
   MITK_INFO << "HighPass: " << m_HighPass;
   MITK_INFO << "LowPass: " << m_LowPass;
 
   MITK_INFO << "cutoffPixelHighPass: " << cutoffPixelHighPass;
   MITK_INFO << "cutoffPixelLowPass: " << cutoffPixelLowPass;
 
   RealImageType::Pointer fftMultiplicator =
     BPFunction(resampledInput, cutoffPixelHighPass, cutoffPixelLowPass, m_HighPassAlpha, m_LowPassAlpha);
 
   typedef itk::MultiplyImageFilter<ComplexImageType, RealImageType, ComplexImageType> MultiplyFilterType;
   MultiplyFilterType::Pointer multiplyFilter = MultiplyFilterType::New();
   multiplyFilter->SetInput1(forwardFFTFilter->GetOutput());
   multiplyFilter->SetInput2(fftMultiplicator);
 
   /*
   GrabItkImageMemory(fftMultiplicator, output);
   mitk::IOUtil::Save(output, "D:/fftImage.nrrd");
 
   typedef itk::ComplexToModulusImageFilter< ComplexImageType, RealImageType > modulusType;
   modulusType::Pointer modul = modulusType::New();
 
   modul->SetInput(multiplyFilter->GetOutput());
   GrabItkImageMemory(modul->GetOutput(), output);
   mitk::IOUtil::Save(output, "D:/fftout.nrrd");
 
   modul->SetInput(forwardFFTFilter->GetOutput());
   GrabItkImageMemory(modul->GetOutput(), output);
   mitk::IOUtil::Save(output, "D:/fftin.nrrd");*/
 
   typedef itk::FFT1DComplexConjugateToRealImageFilter<ComplexImageType, RealImageType> InverseFilterType;
   InverseFilterType::Pointer inverseFFTFilter = InverseFilterType::New();
   inverseFFTFilter->SetInput(multiplyFilter->GetOutput());
   inverseFFTFilter->SetDirection(1);
 
   GrabItkImageMemory(inverseFFTFilter->GetOutput(), output);
 
   double spacing_x = input->GetGeometry()->GetSpacing()[0];
   double spacing_y = input->GetGeometry()->GetSpacing()[1];
   double dim[2] = {spacing_x, spacing_y};
   auto resampledOutput = m_FilterService->ApplyResampling(output, dim);
 
   output->Initialize(mitk::MakeScalarPixelType<float>(), 3, input->GetDimensions());
   output->SetSpacing(resampledOutput->GetGeometry()->GetSpacing());
   ImageReadAccessor copy(resampledOutput);
   output->SetImportVolume(copy.GetData());
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
index 4c1dc490a0..c9fc47cc8c 100644
--- a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
@@ -1,237 +1,272 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPhotoacousticFilterService.h"
 
 #include "mitkITKImageImport.h"
 #include <chrono>
 #include <mitkCropImageFilter.h>
 #include "./OpenCLFilter/mitkPhotoacousticBModeFilter.h"
 #include "mitkConvert2Dto3DImageFilter.h"
 #include <mitkCastToFloatImageFilter.h>
 #include "../ITKFilter/ITKUltrasound/itkBModeImageFilter.h"
 #include "../ITKFilter/itkPhotoacousticBModeImageFilter.h"
 #include <mitkBandpassFilter.h>
 
 // itk dependencies
 #include "itkImage.h"
 #include "itkResampleImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkCropImageFilter.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkIntensityWindowingImageFilter.h"
 #include <itkIndex.h>
 #include "itkBSplineInterpolateImageFunction.h"
 #include <mitkImageToItk.h>
 
 // needed itk image filters
 #include "mitkImageCast.h"
 
 mitk::PhotoacousticFilterService::PhotoacousticFilterService()
 {
   MITK_INFO << "[PhotoacousticFilterService] created filter service";
 }
 
 mitk::PhotoacousticFilterService::~PhotoacousticFilterService()
 {
   MITK_INFO << "[PhotoacousticFilterService] destructed filter service";
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyBmodeFilter(
   mitk::Image::Pointer inputImage,
   BModeMethod method, bool UseLogFilter)
 {
   // the image needs to be of floating point type for the envelope filter to work; the casting is done automatically by the CastToItkImage
   typedef itk::Image< float, 3 > itkFloatImageType;
 
   auto floatImage = ConvertToFloat(inputImage);
 
   if (method == BModeMethod::Abs)
   {
     PhotoacousticBModeFilter::Pointer filter = PhotoacousticBModeFilter::New();
     filter->UseLogFilter(UseLogFilter);
     filter->SetInput(floatImage);
     filter->Update();
     return filter->GetOutput();
   }
 
   typedef itk::BModeImageFilter < itkFloatImageType, itkFloatImageType > BModeFilterType;
   BModeFilterType::Pointer bModeFilter = BModeFilterType::New();  // LogFilter
 
   typedef itk::PhotoacousticBModeImageFilter < itkFloatImageType, itkFloatImageType > PhotoacousticBModeImageFilter;
   PhotoacousticBModeImageFilter::Pointer photoacousticBModeFilter = PhotoacousticBModeImageFilter::New(); // No LogFilter
 
   typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
   ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
 
   itkFloatImageType::Pointer itkImage;
 
   mitk::CastToItkImage(floatImage, itkImage);
 
   if (UseLogFilter)
   {
     bModeFilter->SetInput(itkImage);
     bModeFilter->SetDirection(1);
     itkImage = bModeFilter->GetOutput();
   }
   else
   {
     photoacousticBModeFilter->SetInput(itkImage);
     photoacousticBModeFilter->SetDirection(1);
     itkImage = photoacousticBModeFilter->GetOutput();
   }
 
   return mitk::GrabItkImageMemory(itkImage);
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyResampling(
   mitk::Image::Pointer inputImage,
-  double outputSpacing[2])
+  double *outputSpacing)
 {
   typedef itk::Image< float, 3 > itkFloatImageType;
 
   auto floatImage = ConvertToFloat(inputImage);
 
   typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
   ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
 
   itkFloatImageType::Pointer itkImage;
 
   mitk::CastToItkImage(floatImage, itkImage);
 
   itkFloatImageType::SpacingType outputSpacingItk;
   itkFloatImageType::SizeType inputSizeItk = itkImage->GetLargestPossibleRegion().GetSize();
   itkFloatImageType::SizeType outputSizeItk = inputSizeItk;
 
   outputSpacingItk[0] = outputSpacing[0];
   outputSpacingItk[1] = outputSpacing[1];
   outputSpacingItk[2] = itkImage->GetSpacing()[2];
 
   outputSizeItk[0] = outputSizeItk[0] * (floatImage->GetGeometry()->GetSpacing()[0] / outputSpacing[0]);
   outputSizeItk[1] = outputSizeItk[1] * (floatImage->GetGeometry()->GetSpacing()[1] / outputSpacing[1]);
 
   resampleImageFilter->SetInput(itkImage);
   resampleImageFilter->SetSize(outputSizeItk);
   resampleImageFilter->SetOutputSpacing(outputSpacingItk);
 
   resampleImageFilter->UpdateLargestPossibleRegion();
   return mitk::GrabItkImageMemory(resampleImageFilter->GetOutput());
 }
 
+
+mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyResamplingToDim(
+  mitk::Image::Pointer inputImage,
+  double *outputDimension)
+{
+  typedef itk::Image< float, 3 > itkFloatImageType;
+
+  auto floatImage = ConvertToFloat(inputImage);
+
+  typedef itk::ResampleImageFilter < itkFloatImageType, itkFloatImageType > ResampleImageFilter;
+  ResampleImageFilter::Pointer resampleImageFilter = ResampleImageFilter::New();
+
+  itkFloatImageType::Pointer itkImage;
+
+  mitk::CastToItkImage(floatImage, itkImage);
+
+  itkFloatImageType::SpacingType outputSpacingItk;
+  itkFloatImageType::SizeType inputSizeItk = itkImage->GetLargestPossibleRegion().GetSize();
+  itkFloatImageType::SizeType outputSizeItk = inputSizeItk;
+
+  outputSizeItk[0] = outputDimension[0];
+  outputSizeItk[1] = outputDimension[1];
+
+  outputSpacingItk[0] = (double)outputSizeItk[0] / (double)inputSizeItk[0] * floatImage->GetGeometry()->GetSpacing()[0];
+  outputSpacingItk[1] = (double)outputSizeItk[1] / (double)inputSizeItk[1] * floatImage->GetGeometry()->GetSpacing()[1];
+  outputSpacingItk[2] = itkImage->GetSpacing()[2];
+
+  resampleImageFilter->SetInput(itkImage);
+  resampleImageFilter->SetSize(outputSizeItk);
+  resampleImageFilter->SetOutputSpacing(outputSpacingItk);
+
+  resampleImageFilter->UpdateLargestPossibleRegion();
+  return mitk::GrabItkImageMemory(resampleImageFilter->GetOutput());
+}
+
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyCropping(
   mitk::Image::Pointer inputImage,
   int above, int below,
   int right, int left,
   int zStart, int zEnd)
 {
   try
   {
     auto floatImage = ConvertToFloat(inputImage);
     mitk::CropImageFilter::Pointer cropImageFilter = mitk::CropImageFilter::New();
     cropImageFilter->SetInput(floatImage);
     cropImageFilter->SetXPixelsCropStart(left);
     cropImageFilter->SetXPixelsCropEnd(right);
     cropImageFilter->SetYPixelsCropStart(above);
     cropImageFilter->SetYPixelsCropEnd(below);
     cropImageFilter->SetZPixelsCropStart(zStart);
     cropImageFilter->SetZPixelsCropEnd(zEnd);
     cropImageFilter->Update();
     return cropImageFilter->GetOutput();
   }
   catch (mitk::Exception &e)
   {
     std::string errorMessage = "Caught unexpected exception ";
     errorMessage.append(e.what());
     MITK_ERROR << errorMessage;
 
     return inputImage;
   }
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyBeamforming(
   mitk::Image::Pointer inputImage,
   BeamformingSettings::Pointer config,
   std::function<void(int, std::string)> progressHandle)
 {
   Image::Pointer processedImage = mitk::Image::New();
 
   if (inputImage->GetDimension() != 3)
   {
     mitk::Convert2Dto3DImageFilter::Pointer dimensionImageFilter = mitk::Convert2Dto3DImageFilter::New();
     dimensionImageFilter->SetInput(inputImage);
     dimensionImageFilter->Update();
     processedImage = dimensionImageFilter->GetOutput();
   }
   else
   {
     processedImage = inputImage;
   }
 
   m_BeamformingFilter = mitk::BeamformingFilter::New(config);
   m_BeamformingFilter->SetInput(ConvertToFloat(processedImage));
   m_BeamformingFilter->SetProgressHandle(progressHandle);
   m_BeamformingFilter->UpdateLargestPossibleRegion();
 
   processedImage = m_BeamformingFilter->GetOutput();
 
   return processedImage;
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ApplyBandpassFilter(
   mitk::Image::Pointer data,
   float BPHighPass, float BPLowPass,
   float alphaHighPass, float alphaLowPass,
   float TimeSpacing, float SpeedOfSound, bool IsBFImage)
 {
   try 
   {
     auto floatData = ConvertToFloat(data);
     mitk::BandpassFilter::Pointer bandpassFilter = mitk::BandpassFilter::New();
     bandpassFilter->SetInput(floatData);
     bandpassFilter->SetHighPass(BPHighPass);
     bandpassFilter->SetLowPass(BPLowPass);
     bandpassFilter->SetHighPassAlpha(alphaHighPass);
     bandpassFilter->SetLowPassAlpha(alphaLowPass);
     bandpassFilter->SetSpeedOfSound(SpeedOfSound);
     bandpassFilter->SetTimeSpacing(TimeSpacing);
     bandpassFilter->SetIsBFImage(IsBFImage);
     bandpassFilter->Update();
     return bandpassFilter->GetOutput();
   }
 
   catch (mitk::Exception &e)
   {
     std::string errorMessage = "Caught unexpected exception ";
     errorMessage.append(e.what());
     MITK_ERROR << errorMessage;
 
     return data;
   }
 }
 
 mitk::Image::Pointer mitk::PhotoacousticFilterService::ConvertToFloat(mitk::Image::Pointer inputImage)
 {
   if ((inputImage->GetPixelType().GetTypeAsString() == "scalar (float)" ||
     inputImage->GetPixelType().GetTypeAsString() == " (float)"))
   {
     return inputImage;
   }
 
   mitk::CastToFloatImageFilter::Pointer castToFloatImageFilter = mitk::CastToFloatImageFilter::New();
   castToFloatImageFilter->SetInput(inputImage);
   castToFloatImageFilter->Update();
   return castToFloatImageFilter->GetOutput();
 }