diff --git a/Modules/PhotoacousticsAlgorithms/include/mitkBandpassFilter.h b/Modules/PhotoacousticsAlgorithms/include/mitkBandpassFilter.h
index 6bf5357070..375e34ce34 100644
--- a/Modules/PhotoacousticsAlgorithms/include/mitkBandpassFilter.h
+++ b/Modules/PhotoacousticsAlgorithms/include/mitkBandpassFilter.h
@@ -1,57 +1,59 @@
 /*===================================================================
 
 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_BANDPASS_FILTER
 #define MITK_BANDPASS_FILTER
 
 #include "mitkImageToImageFilter.h"
 #include "MitkPhotoacousticsAlgorithmsExports.h"
 #include "mitkPhotoacousticFilterService.h"
 
 namespace mitk {
   /*!
   * \brief Class implementing an mitk::ImageToImageFilter for casting any mitk image to a float image
   */
 
   class MITKPHOTOACOUSTICSALGORITHMS_EXPORT BandpassFilter : public ImageToImageFilter
   {
   public:
     mitkClassMacro(BandpassFilter, ImageToImageFilter);
 
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     itkSetMacro(HighPass, float);
     itkSetMacro(LowPass, float);
     itkSetMacro(HighPassAlpha, float);
     itkSetMacro(LowPassAlpha, float);
 
   protected:
     BandpassFilter();
 
     ~BandpassFilter() override;
 
+    void SanityCheckPreconditions();
+
     float m_HighPass;
     float m_LowPass;
     float m_HighPassAlpha;
     float m_LowPassAlpha;
     mitk::PhotoacousticFilterService::Pointer m_FilterService;
 
     void GenerateData() override;
   };
 } // namespace mitk
 
 #endif //MITK_CAST_TO_FLOAT_IMAGE_FILTER
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
index 255f9db70c..fe46b66d99 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkBandpassFilter.cpp
@@ -1,256 +1,274 @@
 /*===================================================================
 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 "mitkImageCast.h"
 #include "itkMultiplyImageFilter.h"
 #include "mitkITKImageImport.h"
 #include "mitkIOUtil.h"
 #include "itkComplexToModulusImageFilter.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();
 
   if (!(input->GetPixelType().GetTypeAsString() == "scalar (float)" || input->GetPixelType().GetTypeAsString() == " (float)"))
   {
     MITK_ERROR << "Pixel type is not float, abort";
     mitkThrow() << "Pixel type is not float, abort";
   }
 
   auto output = GetOutput();
   mitk::Image::Pointer resampledInput = input;
 
   bool powerOfTwo = false;
   int finalPower = 0;
   for (int i = 1; pow(2, i) <= input->GetDimension(1); ++i)
   {
     finalPower = i;
     if (pow(2, i) == input->GetDimension(1))
     {
       powerOfTwo = true;
     }
   }
   if (!powerOfTwo)
   {
     double spacing_x = input->GetGeometry()->GetSpacing()[0];
     double spacing_y = input->GetGeometry()->GetSpacing()[1] *
       (((double)input->GetDimensions()[1]) / pow(2, finalPower + 1));
     double dim[2] = { spacing_x, spacing_y };
     resampledInput = m_FilterService->ApplyResampling(input, dim);
   }
 
   // do a fourier transform, multiply with an appropriate window for the filter, and transform back
   typedef itk::Image< float, 3 > RealImageType;
   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 = 2*M_PI / ((float)resampledInput->GetGeometry()->GetSpacing()[1] * resampledInput->GetDimension(1)); // [MHz]
   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);
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
index 7f04518e91..396a2c98c4 100644
--- a/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/filters/mitkCropImageFilter.cpp
@@ -1,112 +1,120 @@
 /*===================================================================
 mitkCropImageFilter
 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 "mitkCropImageFilter.h"
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
 mitk::CropImageFilter::CropImageFilter() :
   m_XPixelsCropEnd(0),
   m_YPixelsCropEnd(0),
   m_ZPixelsCropEnd(0),
   m_XPixelsCropStart(0),
   m_YPixelsCropStart(0),
   m_ZPixelsCropStart(0)
 {
   MITK_INFO << "Instantiating CropImageFilter...";
   SetNumberOfIndexedInputs(1);
   SetNumberOfIndexedOutputs(1);
   MITK_INFO << "Instantiating CropImageFilter...[Done]";
 }
 
 mitk::CropImageFilter::~CropImageFilter()
 {
   MITK_INFO << "Destructed CastToFloatImageFilter.";
 }
 
 void mitk::CropImageFilter::SanityCheckPreconditions()
 {
   mitk::Image::Pointer inputImage = GetInput();
 
   std::string type = inputImage->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_XPixelsCropStart + m_XPixelsCropEnd >= inputImage->GetDimension(0))
+  {
+    MITK_ERROR << "X Crop area too large for selected input image";
     mitkThrow() << "X Crop area too large for selected input image";
+  }
   if (m_YPixelsCropStart + m_YPixelsCropEnd >= inputImage->GetDimension(1))
+  {
+    MITK_ERROR << "Y Crop area too large for selected input image";
     mitkThrow() << "Y Crop area too large for selected input image";
+  }
+
   if (inputImage->GetDimension() == 3)
   {
     if (m_ZPixelsCropStart + m_ZPixelsCropEnd >= inputImage->GetDimension(2))
     {
+      MITK_ERROR << "Y Crop area too large for selected input image";
       mitkThrow() << "Z Crop area too large for selected input image";
     }
   }
   else
   {
     if (m_ZPixelsCropStart + m_ZPixelsCropEnd > 0)
     {
       mitkThrow() << "Z Crop area too large for selected input image";
     }
   }
 }
 
 void mitk::CropImageFilter::GenerateData()
 {
   mitk::Image::Pointer inputImage = GetInput();
   mitk::Image::Pointer outputImage = GetOutput();
 
   SanityCheckPreconditions();
   unsigned int* outputDim;
   unsigned int* inputDim = inputImage->GetDimensions();
 
   if (inputImage->GetDimension() == 2)
     outputDim = new unsigned int[2]{ inputImage->GetDimension(0) - m_XPixelsCropStart - m_XPixelsCropEnd,
     inputImage->GetDimension(1) - m_YPixelsCropStart - m_YPixelsCropEnd };
   else
     outputDim = new unsigned int[3]{ inputImage->GetDimension(0) - m_XPixelsCropStart - m_XPixelsCropEnd,
     inputImage->GetDimension(1) - m_YPixelsCropStart - m_YPixelsCropEnd,
     inputImage->GetDimension(2) - m_ZPixelsCropStart - m_ZPixelsCropEnd };
 
   outputImage->Initialize(mitk::MakeScalarPixelType<float>(), inputImage->GetDimension(), outputDim);
   outputImage->SetSpacing(inputImage->GetGeometry()->GetSpacing());
 
   ImageReadAccessor accR(inputImage);
   const float* inputData = (const float*)(accR.GetData());
 
   ImageWriteAccessor accW(outputImage);
   float* outputData = (float*)(accW.GetData());
 
   unsigned int zLength = inputImage->GetDimension() == 3 ? outputDim[2] : 0;
 
   for (unsigned int sl = 0; sl < zLength; ++sl)
   {
     for (unsigned int l = 0; l < outputDim[0]; ++l)
     {
       for (unsigned int s = 0; s < outputDim[1]; ++s)
       {
         outputData[l + s*outputDim[0] + sl*outputDim[0] * outputDim[1]] =
           inputData[(l + m_XPixelsCropStart) + (s + m_YPixelsCropStart)*inputDim[0] +
           (sl + m_ZPixelsCropStart)*inputDim[0] * inputDim[1]];
       }
     }
   }
   delete[] outputDim;
 }
diff --git a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
index 1a86a6c7a4..2ab8cbca1c 100644
--- a/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
+++ b/Modules/PhotoacousticsAlgorithms/source/utils/mitkPhotoacousticFilterService.cpp
@@ -1,210 +1,233 @@
 /*===================================================================
 
 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])
 {
   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::ApplyCropping(
   mitk::Image::Pointer inputImage,
   int above, int below,
   int right, int left,
   int zStart, int zEnd)
 {
-  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();
+  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)
 {
-  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->Update();
-  return bandpassFilter->GetOutput();
+  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->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();
 }