diff --git a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp
index 7ef273b76c..9e77dd3aac 100644
--- a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp
+++ b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp
@@ -1,101 +1,111 @@
 /*===================================================================
 
 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 "mitkImageToOpenCVImageFilter.h"
 
 #include <itkImportImageFilter.h>
 #include <itkRGBPixel.h>
 #include <mitkImageAccessByItk.h>
 
 namespace mitk{
 
   ImageToOpenCVImageFilter::ImageToOpenCVImageFilter()
     : m_OpenCVImage(0)
   {
+    m_sliceSelector = ImageSliceSelector::New();
   }
 
   ImageToOpenCVImageFilter::~ImageToOpenCVImageFilter()
   {
     m_OpenCVImage = 0;
   }
 
 
   void ImageToOpenCVImageFilter::SetImage( Image* _Image )
   {
     m_Image = _Image;
   }
 
 
   bool ImageToOpenCVImageFilter::CheckImage( Image* image )
   {
     if(image == 0)
     {
       MITK_WARN << "MITK Image is 0";
       return false;
     }
     if(image->GetDimension() > 2 )
     {
       MITK_WARN << "Only 2D Images allowed";
       return false;
     }
     return true;
   }
 
   IplImage* ImageToOpenCVImageFilter::GetOpenCVImage()
   {
 
     if(!this->CheckImage( m_Image ))
       return 0;
 
     m_OpenCVImage = (0);
 
     try
     {
       AccessFixedTypeByItk(m_Image.GetPointer(), ItkImageProcessing,
         MITK_ACCESSBYITK_PIXEL_TYPES_SEQ  // gray image
         (UCRGBPixelType)(USRGBPixelType)(FloatRGBPixelType)(DoubleRGBPixelType), // rgb image
         (2) // dimensions
         )
     }
     catch (const AccessByItkException& e) {
       std::cout << "Caught exception [from AccessFixedTypeByItk]: \n" << e.what() << "\n";
       return 0;
     }
     return m_OpenCVImage;
   }
 
   cv::Mat ImageToOpenCVImageFilter::GetOpenCVMat()
   {
     IplImage* img = this->GetOpenCVImage();
 
     cv::Mat mat;
     if( img )
     {
       // do not copy data, then release just the header
       mat = cv::Mat ( img, false );
       cvReleaseImageHeader( &img );
     }
 
     return mat;
   }
 
   template<typename TPixel, unsigned int VImageDimension>
   void ImageToOpenCVImageFilter::ItkImageProcessing( itk::Image<TPixel,VImageDimension>* image )
   {
     m_OpenCVImage = itk::OpenCVImageBridge::ITKImageToIplImage(image);
   }
 
+  void ImageToOpenCVImageFilter::SetInputFromTimeSlice(Image::Pointer mitkImage, int timeStep, int slice)
+  {
+    m_sliceSelector->SetInput(mitkImage);
+    m_sliceSelector->SetSliceNr(slice);
+    m_sliceSelector->SetTimeNr(timeStep);
+    m_sliceSelector->Update();
+    this->SetImage(m_sliceSelector->GetOutput());
+  }
+
 } // end namespace mitk
\ No newline at end of file
diff --git a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h
index 1a4d1baa33..37d93e4801 100644
--- a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h
+++ b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h
@@ -1,92 +1,105 @@
 /*===================================================================
 
 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 mitkImageToOpenCVImageFilter_h
 #define mitkImageToOpenCVImageFilter_h
 
 #include <mitkCommon.h>
 #include <mitkImage.h>
 #include <mitkWeakPointer.h>
 #include <itkOpenCVImageBridge.h>
 #include <MitkOpenCVVideoSupportExports.h>
 
 namespace mitk
 {
 
 ///
 /// \brief A pseudo-Filter for creating OpenCV images from MITK images with the option of copying data or referencing it
 ///
 class MITKOPENCVVIDEOSUPPORT_EXPORT ImageToOpenCVImageFilter : public itk::Object
 {
     public:
         typedef itk::RGBPixel< unsigned char > UCRGBPixelType;
         typedef itk::RGBPixel< unsigned short > USRGBPixelType;
         typedef itk::RGBPixel< float > FloatRGBPixelType;
         typedef itk::RGBPixel< double > DoubleRGBPixelType;
 
         mitkClassMacro(ImageToOpenCVImageFilter, itk::Object);
         itkFactorylessNewMacro(Self)
         itkCloneMacro(Self)
 
         ///
         /// \brief set the input MITK image
         ///
         void SetImage( mitk::Image* _Image );
         ///
         /// \brief get the input MITK image
         ///
         itkGetMacro(Image, mitk::Image*);
 
         ///
         /// \brief get the input MITK image
         ///
         bool CheckImage(mitk::Image* image);
 
         ///
         /// RUNS the conversion and returns the produced OpenCVImage.
         /// !!!ATTENTION!!! Do not forget to release this image again with cvReleaseImage().
         /// \return the produced OpenCVImage or 0 if an error occured!
         ///
         IplImage* GetOpenCVImage();
 
         ///
         /// RUNS the conversion and returns the produced image as cv::Mat.
         /// \return the produced OpenCVImage or an empty image if an error occured
         ///
         cv::Mat GetOpenCVMat();
 
+        //##Documentation
+        //## @brief Convenient method to set a certain slice of a 3D or 4D mitk::Image as input to convert it to an openCV image
+        //##
+        //## This methods sets the input. Call GetOpenCVMat() or GetOpenCVImage() to get the image.
+        //##
+        //## @param mitkImage - the image that should be converted to an openCVImage
+        //## @param timeStep - the time step, which is converted to openCV
+        //## @param slice - the slice which is converted to openCV
+        void SetInputFromTimeSlice(Image::Pointer mitkImage, int timeStep, int slice);
+
     protected:
         ///
         /// the actual templated conversion method
         ///
         template<typename TPixel, unsigned int VImageDimension>
         void ItkImageProcessing( itk::Image<TPixel,VImageDimension>* image );
 
         ImageToOpenCVImageFilter();
         ~ImageToOpenCVImageFilter();
 
         ///
         /// Saves if the filter should copy the data or just reference it
         ///
         mitk::WeakPointer<mitk::Image> m_Image;
         IplImage* m_OpenCVImage;
+
+  private:
+    ImageSliceSelector::Pointer m_sliceSelector;
 };
 
 } // namespace
 
 #endif // mitkImageToOpenCVImageFilter_h
 
 
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
index bcf65c7497..7964437108 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp
@@ -1,159 +1,178 @@
 /*===================================================================
 
 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 "mitkOpenCVToMitkImageFilter.h"
 
 #include <itkImportImageFilter.h>
 #include <itkRGBPixel.h>
 #include <mitkITKImageImport.txx>
 #include <itkOpenCVImageBridge.h>
 #include <itkImageFileWriter.h>
 
 #include "mitkImageToOpenCVImageFilter.h"
 
 namespace mitk{
 
   OpenCVToMitkImageFilter::OpenCVToMitkImageFilter()
     : m_OpenCVImage(0)
   {
   }
 
   OpenCVToMitkImageFilter::~OpenCVToMitkImageFilter()
   {
   }
 
   void OpenCVToMitkImageFilter::SetOpenCVImage(const IplImage* image)
   {
     this->m_OpenCVImage = image;
     this->m_OpenCVMat.release();
     this->Modified();
   }
 
   void OpenCVToMitkImageFilter::GenerateData()
   {
     IplImage cvMatIplImage;
     const IplImage* targetImage = 0;
     if(m_OpenCVImage == 0)
     {
       if( m_OpenCVMat.cols == 0 || m_OpenCVMat.rows == 0 )
       {
         MITK_WARN << "Cannot not start filter. OpenCV Image not set.";
         return;
       }
       else
       {
         cvMatIplImage = m_OpenCVMat;
         targetImage = &cvMatIplImage;
       }
     }
     else
       targetImage = m_OpenCVImage;
 
     // now convert rgb image
     if( (targetImage->depth>=0) && ((unsigned int)targetImage->depth == IPL_DEPTH_8S) && (targetImage->nChannels == 1) )
       m_Image = ConvertIplToMitkImage< char, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_8U && targetImage->nChannels == 1 )
       m_Image = ConvertIplToMitkImage< unsigned char, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_8U && targetImage->nChannels == 3 )
       m_Image = ConvertIplToMitkImage< UCRGBPixelType, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_16U && targetImage->nChannels == 1 )
       m_Image = ConvertIplToMitkImage< unsigned short, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_16U && targetImage->nChannels == 3 )
       m_Image = ConvertIplToMitkImage< USRGBPixelType, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_32F && targetImage->nChannels == 1 )
       m_Image = ConvertIplToMitkImage< float, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_32F && targetImage->nChannels == 3 )
       m_Image = ConvertIplToMitkImage< FloatRGBPixelType , 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_64F && targetImage->nChannels == 1 )
       m_Image = ConvertIplToMitkImage< double, 2>( targetImage );
 
     else if( targetImage->depth == IPL_DEPTH_64F && targetImage->nChannels == 3 )
       m_Image = ConvertIplToMitkImage< DoubleRGBPixelType , 2>( targetImage );
 
     else
     {
       MITK_WARN << "Unknown image depth and/or pixel type. Cannot convert OpenCV to MITK image.";
       return;
     }
 
     //cvReleaseImage(&rgbOpenCVImage);
   }
 
   ImageSource::OutputImageType* OpenCVToMitkImageFilter::GetOutput()
   {
     return m_Image;
   }
 
   /********************************************
   * Converting from OpenCV image to ITK Image
   *********************************************/
   template <typename TPixel, unsigned int VImageDimension>
   Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertIplToMitkImage( const IplImage * input )
   {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
 
     typename ImageType::Pointer output = ImageType::New();
     typename ImageType::RegionType region;
     typename ImageType::RegionType::SizeType size;
     typename ImageType::RegionType::IndexType index;
     typename ImageType::SpacingType spacing;
     size.Fill( 1 );
     size[0] = input->width;
     size[1] = input->height;
     index.Fill(0);
     spacing.Fill(1);
     region.SetSize(size);
     region.SetIndex(index);
     output->SetRegions(region);
     output->SetSpacing(spacing);
     output->Allocate();
 
     // CAVE: The itk openCV bridge seem to NOT correctly copy the image data, hence the call to
     // itk::OpenCVImageBridge::IplImageToITKImage<ImageType>() is simply used to initialize the itk image
     // and in the next step the image data are copied by hand!
 
     if(input->nChannels == 3) // these are RGB images and need to be set to BGR before conversion!
     {
       output = itk::OpenCVImageBridge::IplImageToITKImage<ImageType>(input);
     }
     else
     {
       memcpy((void*) output->GetBufferPointer(), (void*) input->imageDataOrigin,
         input->width*input->height*sizeof(TPixel));
     }
 
     Image::Pointer mitkImage = Image::New();
     mitkImage = GrabItkImageMemory(output);
 
     return mitkImage;
   }
 
 
   void OpenCVToMitkImageFilter::SetOpenCVMat(const cv::Mat &image)
   {
     m_OpenCVMat = image;
     m_OpenCVImage = NULL;
     this->Modified();
   }
 
+  void OpenCVToMitkImageFilter::InsertOpenCVImageAsMitkTimeSlice(cv::Mat openCVImage, Image::Pointer mitkImage, int timeStep)
+  {
+    // convert it to an mitk::Image
+    this->SetOpenCVMat(openCVImage);
+    this->Modified();
+    this->Update();
+
+    //insert it as a timeSlice
+    mitkImage->GetGeometry(timeStep)->SetSpacing(this->GetOutput()->GetGeometry()->GetSpacing());
+    mitkImage->GetGeometry(timeStep)->SetOrigin(this->GetOutput()->GetGeometry()->GetOrigin());
+    mitkImage->GetGeometry(timeStep)->SetIndexToWorldTransform(this->GetOutput()->GetGeometry()->GetIndexToWorldTransform());
+    mitkImage->SetImportVolume(this->GetOutput()->GetData(), timeStep);
+
+    mitkImage->Modified();
+    mitkImage->Update();
+
+    m_Image = mitkImage;
+  }
+
 } // end namespace mitk
diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
index 6a818b2eef..8bd2dd8605 100644
--- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
+++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h
@@ -1,85 +1,96 @@
 /*===================================================================
 
 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 mitkOpenCVToMitkImageFilter_h
 #define mitkOpenCVToMitkImageFilter_h
 
 // mitk includes
 #include <MitkOpenCVVideoSupportExports.h>
 #include <mitkCommon.h>
 #include <mitkImageSource.h>
 
 // itk includes
 #include <itkMacro.h>
 #include <itkImage.h>
 
 // OpenCV includes
 #include <cv.h>
 
 namespace mitk
 {
 
 ///
 /// \brief Filter for creating MITK RGB Images from an OpenCV image
 ///
 class MITKOPENCVVIDEOSUPPORT_EXPORT OpenCVToMitkImageFilter : public ImageSource
 {
   public:
     typedef itk::RGBPixel< unsigned char > UCRGBPixelType;
     typedef itk::RGBPixel< unsigned short > USRGBPixelType;
     typedef itk::RGBPixel< float > FloatRGBPixelType;
     typedef itk::RGBPixel< double > DoubleRGBPixelType;
 
     ///
     /// the static function for the conversion
     ///
     template <typename TPixel, unsigned int VImageDimension>
     static Image::Pointer ConvertIplToMitkImage( const IplImage * input );
 
     mitkClassMacro(OpenCVToMitkImageFilter, ImageSource);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     ///
     /// sets an iplimage as input
     ///
     void SetOpenCVImage(const IplImage* image);
     itkGetMacro(OpenCVImage, const IplImage*);
 
     ///
     /// sets an opencv mat as input (will be used if OpenCVImage Ipl image is 0)
     ///
     void SetOpenCVMat(const cv::Mat& image);
     itkGetMacro(OpenCVMat, cv::Mat);
 
     OutputImageType* GetOutput(void);
 
+    //##Documentation
+    //## @brief Convenient method to insert an openCV image as a slice at a
+    //## certain time step into a 3D or 4D mitk::Image.
+    //##
+    //## @param openCVImage - the image that is inserted into the mitk Image
+    //## @param mitkImage - pointer to the mitkImage, which is changed by this method!
+    //## @param timeStep - the time step, at which the openCVImage is inserted
+    //##
+    //## @attention The parameter mitkImage will be changed!
+    void InsertOpenCVImageAsMitkTimeSlice(const cv::Mat openCVImage, Image::Pointer mitkImage, int timeStep);
+
   protected:
 
     OpenCVToMitkImageFilter(); // purposely hidden
     virtual ~OpenCVToMitkImageFilter();
 
     virtual void GenerateData();
 
 protected:
     Image::Pointer m_Image;
     const IplImage* m_OpenCVImage;
     cv::Mat m_OpenCVMat;
 };
 
 } // namespace mitk
 
 #endif // mitkOpenCVToMitkImageFilter_h