diff --git a/Modules/BasicImageProcessing/include/mitkArithmeticOperation.h b/Modules/BasicImageProcessing/include/mitkArithmeticOperation.h
index ddbcb35662..7c661e6519 100644
--- a/Modules/BasicImageProcessing/include/mitkArithmeticOperation.h
+++ b/Modules/BasicImageProcessing/include/mitkArithmeticOperation.h
@@ -1,34 +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.
 
 ===================================================================*/
 
 #ifndef mitkArithmeticOperation_h
 #define mitkArithmeticOperation_h
 
 #include <mitkImage.h>
 #include <MitkBasicImageProcessingExports.h>
 
 namespace mitk
 {
   /** \brief Executes a arithmetic operations on one or two images
   *
   * All parameters of the arithmetic operations must be specified during construction.
   * The actual operation is executed when calling GetResult().
   */
   class MITKBASICIMAGEPROCESSING_EXPORT ArithmeticOperation {
-    static mitk::Image::Pointer Add(mitk::Image::Pointer & imageA, mitk::Image::Pointer & imageB, bool outputAsDouble = true);
-}
+  public:
+    static Image::Pointer Add(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble = true);
+    static Image::Pointer Subtract(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble = true);
+    static Image::Pointer Multiply(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble = true);
+    static Image::Pointer Divide(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble = true);
+    //static Image::Pointer Exp(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble = true);
+
+    static Image::Pointer Add(Image::Pointer & imageA, double value, bool outputAsDouble = true);
+    //static Image::Pointer Subtract(Image::Pointer & imageA, double value, bool outputAsDouble = true);
+    //static Image::Pointer Multiply(Image::Pointer & imageA, double value, bool outputAsDouble = true);
+    //static Image::Pointer Divide(Image::Pointer & imageA, double value, bool outputAsDouble = true);
+
+    //static Image::Pointer Add(double value, Image::Pointer & imageB, bool outputAsDouble = true);
+    //static Image::Pointer Subtract(double value, Image::Pointer & imageB, bool outputAsDouble = true);
+    //static Image::Pointer Multiply(double value, Image::Pointer & imageB, bool outputAsDouble = true);
+    //static Image::Pointer Divide(double value, Image::Pointer & imageB, bool outputAsDouble = true);
+
+    //static Image::Pointer Log(Image::Pointer & imageA, bool outputAsDouble = true);
+    //static Image::Pointer Exp(Image::Pointer & imageA, bool outputAsDouble = true);
+ };
+
+  class MITKBASICIMAGEPROCESSING_EXPORT NonStaticArithmeticOperation {
+  public:
+    enum OperationsEnum
+    {
+      Add2,
+      Sub2,
+      Mult,
+      Div,
+      AddValue
+    };
+
 
+    void CallExecuteTwoImageFilter(mitk::Image::Pointer imageA, mitk::Image::Pointer imageB);
+
+    template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
+    void ExecuteTwoImageFilter(itk::Image<TPixel1, VImageDimension1>* imageA, itk::Image<TPixel2, VImageDimension2>* imageB);
+
+    template<typename DefaultFunctorType, typename DoubleFunctorType, typename Image1Type, typename Image2Type, typename DoubleImageType>
+    void ExecuteTwoImageFilterWithFunctor(Image1Type* imageA, Image2Type* imageB);
+
+    mitk::Image::Pointer m_ResultImage;
+    OperationsEnum m_Algorithm;
+    bool m_GenerateDoubleOutput = false;
+  };
+
+
+}
 #endif // mitkArithmeticOperation_h
\ No newline at end of file
diff --git a/Modules/BasicImageProcessing/include/mitkEmptyClass.h b/Modules/BasicImageProcessing/include/mitkEmptyClass.h
index 21ca355baa..1b840fc7d3 100644
--- a/Modules/BasicImageProcessing/include/mitkEmptyClass.h
+++ b/Modules/BasicImageProcessing/include/mitkEmptyClass.h
@@ -1,12 +1,12 @@
 #ifndef mitkEmptyClass_h
 #define mitkEmptyClass_h
 
 #include <MitkBasicImageProcessingExports.h>
 
 class MITKBASICIMAGEPROCESSING_EXPORT mitkEmptyClass {
   public:
     int m_Meaningless;
     void foo();
-}
+};
 
 #endif
\ No newline at end of file
diff --git a/Modules/BasicImageProcessing/src/mitkArithmeticOperation.cpp b/Modules/BasicImageProcessing/src/mitkArithmeticOperation.cpp
index 4be193b9f8..94ce5bc170 100644
--- a/Modules/BasicImageProcessing/src/mitkArithmeticOperation.cpp
+++ b/Modules/BasicImageProcessing/src/mitkArithmeticOperation.cpp
@@ -1,5 +1,228 @@
-#include <mitkEmptyClass.h>
+/*===================================================================
 
-void mitkEmptyClass::foo(){
-  
-};
\ No newline at end of file
+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 "mitkArithmeticOperation.h"
+
+#include <mitkImage.h>
+#include <mitkImageAccessByItk.h>
+#include <mitkImageCast.h>
+
+#include <itkArithmeticOpsFunctors.h>
+#include <itkImage.h>
+#include "itkUnaryFunctorImageFilter.h"
+#include <itkBinaryFunctorImageFilter.h>
+namespace mitk
+{
+  namespace Functor
+  {
+    template< class TInput, class TOutput>
+    class AddValue
+    {
+    public:
+      AddValue() {};
+      ~AddValue() {};
+      bool operator!=(const AddValue &) const
+      {
+        return false;
+      }
+      bool operator==(const AddValue & other) const
+      {
+        return !(*this != other);
+      }
+      inline TOutput operator()(const TInput & A) const
+      {
+        return A + value;
+      }
+
+      bool valueLeft = false;
+      double value = 0.0;
+    };
+  }
+}
+
+template<typename TPixel, unsigned int VImageDimension>
+static void ExecuteOneImageFilter(itk::Image<TPixel, VImageDimension>* imageA, double value, bool returnDoubleImage, bool valueLeft, mitk::NonStaticArithmeticOperation::OperationsEnum algorithm, mitk::Image::Pointer & outputImage)
+{
+  typedef itk::Image<TPixel, VImageDimension> ImageType;
+  typedef itk::Image<double, VImageDimension> DoubleOutputType;
+
+
+  switch (algorithm) {
+  case OperationsEnum::AddValue:
+    ExecuteOneImageFilterWithFunctor<mitk::Functor::AddValue<TPixel, TPixel>,
+                                     mitk::Functor::AddValue<TPixel, double>,
+                                     ImageType, DoubleOutputType>(imageA, value, valueLeft, returnDoubleImage, mitk::Image::Pointer & outputImage);
+    break;
+  }
+}
+
+template<typename DefaultFunctorType, typename DoubleFunctorType, typename ImageType, typename DoubleImageType >
+static void ExecuteOneImageFilterWithFunctor(ImageType* imageA, double value, bool returnDoubleImage, bool valueLeft, mitk::Image::Pointer & outputImage)
+{
+  typedef itk::UnaryFunctorImageFilter< Image1Type, Image1Type, DefaultFunctorType > DefaultFilterType;
+  typedef itk::UnaryFunctorImageFilter< Image1Type, DoubleImageType, DoubleFunctorType > DoubleFilterType;
+
+  if (returnDoubleImage)
+  {
+    DoubleFunctorType functor;
+    functor.valueLeft = valueLeft;
+    functor.value = value;
+    typename DoubleFilterType::Pointer filter = DoubleFilterType::New();
+    filter->SetInput1(imageA);
+    filter->SetFunctor(functor);
+    filter->Update();
+    CastToMitkImage(filter->GetOutput(), outputImage);
+  }
+  else
+  {
+    DefaultFunctorType functor;
+    functor.valueLeft = valueLeft;
+    functor.value = value;
+    typename DefaultFilterType::Pointer filter = DefaultFilterType::New();
+    filter->SetInput1(imageA);
+    filter->SetFunctor(functor);
+    filter->Update();
+    CastToMitkImage(filter->GetOutput(), outputImage);
+  }
+}
+
+
+mitk::Image::Pointer mitk::ArithmeticOperation::Add(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble)
+{
+  NonStaticArithmeticOperation helper;
+  helper.m_Algorithm = NonStaticArithmeticOperation::OperationsEnum::Add2;
+  helper.CallExecuteTwoImageFilter(imageA, imageB);
+  return helper.m_ResultImage;
+}
+
+mitk::Image::Pointer mitk::ArithmeticOperation::Subtract(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble)
+{
+  NonStaticArithmeticOperation helper;
+  helper.m_Algorithm = NonStaticArithmeticOperation::OperationsEnum::Sub2;
+  helper.CallExecuteTwoImageFilter(imageA, imageB);
+  return helper.m_ResultImage;
+}
+
+mitk::Image::Pointer mitk::ArithmeticOperation::Multiply(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble)
+{
+  NonStaticArithmeticOperation helper;
+  helper.m_Algorithm = NonStaticArithmeticOperation::OperationsEnum::Mult;
+  helper.CallExecuteTwoImageFilter(imageA, imageB);
+  return helper.m_ResultImage;
+}
+
+mitk::Image::Pointer mitk::ArithmeticOperation::Divide(Image::Pointer & imageA, Image::Pointer & imageB, bool outputAsDouble)
+{
+  NonStaticArithmeticOperation helper;
+  helper.m_Algorithm = NonStaticArithmeticOperation::OperationsEnum::Div;
+  helper.CallExecuteTwoImageFilter(imageA, imageB);
+  return helper.m_ResultImage;
+}
+
+mitk::Image::Pointer mitk::ArithmeticOperation::Add(Image::Pointer & imageA, double value, bool outputAsDouble)
+{
+  mitk::Image::Pointer resultImage;
+  AccessByItk_n(imageA, ExecuteOneImageFilter, (value, outputAsDouble, false, NonStaticArithmeticOperation::OperationsEnum::AddValue, resultImage));
+  return resultImage;
+}
+
+
+void mitk::NonStaticArithmeticOperation::CallExecuteTwoImageFilter(mitk::Image::Pointer imageA, mitk::Image::Pointer imageB)
+{
+  if (imageA->GetDimension() != imageB->GetDimension())
+  {
+    mitkThrow() << "Image have different dimensions. This is not supported by mitk::ArithmeticOperation";
+  }
+
+  switch (imageA->GetDimension())
+  {
+  case 1:
+    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 1);
+    break;
+  case 2:
+    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 2);
+    break;
+  case 3:
+    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 3);
+    break;
+  case 4:
+    AccessTwoImagesFixedDimensionByItk(imageA, imageB, mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter, 4);
+    break;
+  default:
+    mitkThrow() << "Image Dimension of "<<imageA->GetDimension() << " is not supported";
+    break;
+  }
+}
+
+
+template<typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
+void mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilter(itk::Image<TPixel1, VImageDimension1>* imageA, itk::Image<TPixel2, VImageDimension2>* imageB)
+{
+  typedef itk::Image<TPixel1, VImageDimension1> Image1Type;
+  typedef itk::Image<TPixel2, VImageDimension2> Image2Type;
+  typedef itk::Image<double, VImageDimension1> DoubleOutputType;
+
+
+  switch (m_Algorithm) {
+  case OperationsEnum::Add2:
+    ExecuteTwoImageFilterWithFunctor<itk::Functor::Add2<TPixel1, TPixel2, TPixel1>,
+                                     itk::Functor::Add2<TPixel1, TPixel2, double>,
+                                     Image1Type, Image2Type, DoubleOutputType>(imageA, imageB);
+    break;
+
+  case OperationsEnum::Sub2:
+    ExecuteTwoImageFilterWithFunctor<itk::Functor::Sub2<TPixel1, TPixel2, TPixel1>,
+      itk::Functor::Add2<TPixel1, TPixel2, double>,
+      Image1Type, Image2Type, DoubleOutputType>(imageA, imageB);
+    break;
+
+  case OperationsEnum::Mult:
+    ExecuteTwoImageFilterWithFunctor<itk::Functor::Mult<TPixel1, TPixel2, TPixel1>,
+      itk::Functor::Add2<TPixel1, TPixel2, double>,
+      Image1Type, Image2Type, DoubleOutputType>(imageA, imageB);
+    break;
+
+  case OperationsEnum::Div:
+    ExecuteTwoImageFilterWithFunctor<itk::Functor::Div<TPixel1, TPixel2, TPixel1>,
+      itk::Functor::Add2<TPixel1, TPixel2, double>,
+      Image1Type, Image2Type, DoubleOutputType>(imageA, imageB);
+    break;
+  }
+}
+
+template<typename DefaultFunctorType, typename DoubleFunctorType, typename Image1Type, typename Image2Type, typename DoubleImageType >
+void mitk::NonStaticArithmeticOperation::ExecuteTwoImageFilterWithFunctor(Image1Type* imageA, Image2Type* imageB)
+{
+  typedef itk::BinaryFunctorImageFilter< Image1Type, Image2Type, Image1Type,DefaultFunctorType > DefaultFilterType;
+  typedef itk::BinaryFunctorImageFilter< Image1Type, Image2Type, DoubleImageType, DoubleFunctorType > DoubleFilterType;
+
+  if (m_GenerateDoubleOutput)
+  {
+    typename DoubleFilterType::Pointer filter = DoubleFilterType::New();
+    filter->SetInput1(imageA);
+    filter->SetInput2(imageB);
+    filter->Update();
+    CastToMitkImage(filter->GetOutput(), m_ResultImage);
+  }
+  else
+  {
+    typename DefaultFilterType::Pointer filter = DefaultFilterType::New();
+    filter->SetInput1(imageA);
+    filter->SetInput2(imageB);
+    filter->Update();
+    CastToMitkImage(filter->GetOutput(), m_ResultImage);
+  }
+}
\ No newline at end of file