diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp b/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
index cc53a4c0c1..e07f0d2a2a 100644
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeSlicedGeometry.cpp
@@ -1,418 +1,434 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkTimeSlicedGeometry.h"
 
 void mitk::TimeSlicedGeometry::UpdateInformation()
 {
   if(m_TimeSteps==0) return;
 
   unsigned long maxModifiedTime = 0, curModifiedTime;
 
   mitk::ScalarType stmin, stmax;
   stmin= ScalarTypeNumericTraits::NonpositiveMin();
   stmax= ScalarTypeNumericTraits::max();
 
   TimeBounds timeBounds;
   timeBounds[0]=stmax; timeBounds[1]=stmin;
 
   mitk::BoundingBox::Pointer boundingBox=mitk::BoundingBox::New();
 
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
 
   unsigned int t;
 
   mitk::Geometry3D* geometry3d;
   mitk::BoundingBox::ConstPointer nextBoundingBox;
   mitk::BoundingBox::PointIdentifier pointid=0;
 
   // Need to check for zero bounding boxes
   mitk::ScalarType zeropoint[]={0,0,0,0,0,0};
   BoundingBox::BoundsArrayType itkBoundsZero(zeropoint);
 
   for(t=0; t < m_TimeSteps; ++t)
   {
     geometry3d = GetGeometry3D(t);
     assert(geometry3d!=NULL);
 
     curModifiedTime = geometry3d->GetMTime();
     if(maxModifiedTime < curModifiedTime)
       maxModifiedTime = curModifiedTime;
 
     const TimeBounds & curTimeBounds = geometry3d->GetTimeBounds();
     if((curTimeBounds[0] > stmin) && (curTimeBounds[0] < timeBounds[0]))
       timeBounds[0] = curTimeBounds[0];
     if((curTimeBounds[1] < stmax) && (curTimeBounds[1] > timeBounds[1]))
       timeBounds[1] = curTimeBounds[1];
 
     nextBoundingBox = geometry3d->GetBoundingBox();
     assert(nextBoundingBox.IsNotNull());
 
     // Only respect non-zero BBes
     if (nextBoundingBox->GetBounds() == itkBoundsZero)
     {
       continue;
     }
 
     const mitk::BoundingBox::PointsContainer * nextPoints = nextBoundingBox->GetPoints();
     if(nextPoints!=NULL)
     {
       mitk::BoundingBox::PointsContainer::ConstIterator pointsIt = nextPoints->Begin();
 
       while (pointsIt != nextPoints->End() )
       {
         pointscontainer->InsertElement( pointid++, pointsIt->Value());
         ++pointsIt;
       }
     }
   }
 
   if(!(timeBounds[0] < stmax))
   {
     timeBounds[0] = stmin;
     timeBounds[1] = stmax;
   }
 
   m_TimeBounds = timeBounds;
   assert(timeBounds[0]<=timeBounds[1]);
 
   boundingBox->SetPoints(pointscontainer);
 
   boundingBox->ComputeBoundingBox();
 
   m_BoundingBox = boundingBox;
 
   SetIndexToWorldTransform(GetGeometry3D(0)->GetIndexToWorldTransform());
 
   if(this->GetMTime() < maxModifiedTime)
     Modified();
 }
 
 mitk::Geometry3D* mitk::TimeSlicedGeometry::GetGeometry3D(int t) const
 {
   mitk::Geometry3D::Pointer geometry3d = NULL;
   if(IsValidTime(t))
   {
     geometry3d = m_Geometry3Ds[t];
     //if (a) we don't have a Geometry3D stored for the requested time, 
     //(b) m_EvenlyTimed is activated and (c) the first geometry (t=0) 
     //is set, then we clone the geometry and set the m_TimeBounds accordingly.
     if((m_EvenlyTimed) && (geometry3d.IsNull()))
     {
       const Geometry3D* firstgeometry=m_Geometry3Ds[0].GetPointer();
 
       assert(firstgeometry != NULL);
 
       mitk::Geometry3D::Pointer requestedgeometry;
       requestedgeometry = dynamic_cast<Geometry3D*>(firstgeometry->Clone().GetPointer());
       if ( requestedgeometry.IsNull() ) itkExceptionMacro("Geometry is NULL!");
 
       TimeBounds timebounds = requestedgeometry->GetTimeBounds();
       if(timebounds[1]<ScalarTypeNumericTraits::max())
       {
         mitk::ScalarType later = (timebounds[1]-timebounds[0])*t;
         timebounds[0]+=later; timebounds[1]+=later;
         requestedgeometry->SetTimeBounds(timebounds);
       }
 
       geometry3d = requestedgeometry;
       m_Geometry3Ds[t] = geometry3d;
     }
   }
   else
     return NULL;
   return geometry3d;
 }
 
 bool mitk::TimeSlicedGeometry::SetGeometry3D(mitk::Geometry3D* geometry3D, int t)
 {
   if(IsValidTime(t))
   {
     m_Geometry3Ds[t]=geometry3D;
     return true;
   }
   return false;
 }
 
 int mitk::TimeSlicedGeometry::MSToTimeStep(mitk::ScalarType time_in_ms) const
 {
   if(time_in_ms < m_TimeBounds[0])
     return -1;
   if(time_in_ms >= m_TimeBounds[1])
     return m_TimeSteps;
   if(m_EvenlyTimed)
   {
     if(m_TimeBounds[0] == m_TimeBounds[1])
       return 0;
     if((m_TimeBounds[0]>ScalarTypeNumericTraits::NonpositiveMin()) && (m_TimeBounds[1]<ScalarTypeNumericTraits::max()))
     {   
       return (int) ceil(((time_in_ms - m_TimeBounds[0])/(m_TimeBounds[1]-m_TimeBounds[0])*m_TimeSteps)-0.5);
     }
     return 0;
   }
   else
   {
     unsigned int t;
     for ( t = 0; t < m_TimeSteps; ++t )
     {
       const TimeBounds& timeBounds = GetGeometry3D( t )->GetTimeBounds();
       if( (timeBounds[0] <= time_in_ms) && (time_in_ms <= timeBounds[1]) )
       {
         return t;
       }
     }
   }
   return 0;
 }
 
 mitk::ScalarType mitk::TimeSlicedGeometry::TimeStepToMS(int timestep) const
 {
   if(IsValidTime(timestep)==false)
     return ScalarTypeNumericTraits::max();
   if(m_EvenlyTimed)
   {
     if ( timestep == 0 )
       return m_TimeBounds[0];
     else 
     {
       assert( ! (m_TimeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin() && m_TimeBounds[1] == ScalarTypeNumericTraits::max() ) );
       return ((mitk::ScalarType)timestep)/m_TimeSteps*(m_TimeBounds[1]-m_TimeBounds[0])+m_TimeBounds[0];
     }
   }
   else
   {
     return GetGeometry3D(timestep)->GetTimeBounds()[0];
   }
 }
 
 int mitk::TimeSlicedGeometry::TimeStepToTimeStep(
   const mitk::TimeSlicedGeometry *referenceGeometry, int t) const
 {
   int timeStep;
   if ( referenceGeometry->GetTimeSteps() > 1 )
   {
     // referenceGeometry is nD+t
     timeStep = this->MSToTimeStep( referenceGeometry->TimeStepToMS( t ) );
   }
   else
   {
     // referenceGEometry is nD (only one time step)
     timeStep = 0;
   }
 
   return timeStep;
 }
 
 
 void mitk::TimeSlicedGeometry::Initialize(unsigned int timeSteps)
 {
   Geometry3D::Pointer geometry3D = Geometry3D::New();
   geometry3D->Initialize();
   InitializeEvenlyTimed(geometry3D, timeSteps);
 }
 
 void mitk::TimeSlicedGeometry::InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps)
 {
   assert(geometry3D!=NULL);
 
   geometry3D->Register();
 
   InitializeEmpty(timeSteps);
 
   AffineTransform3D::Pointer transform = AffineTransform3D::New();
   transform->SetMatrix(geometry3D->GetIndexToWorldTransform()->GetMatrix());
   transform->SetOffset(geometry3D->GetIndexToWorldTransform()->GetOffset());
   SetIndexToWorldTransform(transform);
 
   SetBounds(geometry3D->GetBounds());
   SetGeometry3D(geometry3D, 0);
   SetEvenlyTimed();
 
   UpdateInformation();
 
   SetFrameOfReferenceID(geometry3D->GetFrameOfReferenceID());
   SetImageGeometry(geometry3D->GetImageGeometry());
 
   geometry3D->UnRegister();
 }
 
 void mitk::TimeSlicedGeometry::InitializeEmpty(unsigned int timeSteps)
 {
   m_IndexToWorldTransform = NULL;
 
   Superclass::Initialize();
 
   m_TimeSteps = timeSteps;
 
   // initialize with empty geometries
   Geometry3D::Pointer gnull=NULL;
   m_Geometry3Ds.assign(m_TimeSteps, gnull);
 }
 
 void mitk::TimeSlicedGeometry::ExpandToNumberOfTimeSteps( unsigned int timeSteps )
 {
   if( timeSteps <= m_TimeSteps ) return;
 
   if(m_TimeSteps == 1)
   {
     Geometry3D* g3d = m_Geometry3Ds[0];
     const TimeBounds & timeBounds = g3d->GetTimeBounds();
     if( (timeBounds[0] == ScalarTypeNumericTraits::NonpositiveMin()) || 
         (timeBounds[1]==ScalarTypeNumericTraits::max())
       )
     {
       mitk::ScalarType timeBounds[] = {0.0, 1.0};
       m_Geometry3Ds[0]->SetTimeBounds( timeBounds );
     }
   }
 
   // Expand to Number of time steps; initialize with empty geometries
   Geometry3D::Pointer gnull=NULL;
   m_Geometry3Ds.resize(timeSteps, gnull);
 
   m_TimeSteps = timeSteps;
 
   UpdateInformation();
 }
 
 mitk::TimeSlicedGeometry::TimeSlicedGeometry() : m_TimeSteps(0), m_EvenlyTimed(false)
 {
 }
 
+mitk::TimeSlicedGeometry::TimeSlicedGeometry(const TimeSlicedGeometry& other) : Geometry3D(other), m_TimeSteps(other.m_TimeSteps), m_EvenlyTimed(other.m_EvenlyTimed)
+{
+  m_Geometry3Ds.resize(m_TimeSteps);
+  unsigned int t;
+  for(t=0; t<m_TimeSteps; ++t)
+  {
+    if(other.m_Geometry3Ds[t].IsNull())
+    {
+      assert(other.m_EvenlyTimed);
+      SetGeometry3D(NULL,t);
+    }
+    else
+    {
+      SetGeometry3D(dynamic_cast<Geometry3D*>(other.m_Geometry3Ds[t]->Clone().GetPointer()), t);
+    }
+  }
+}
+
 mitk::TimeSlicedGeometry::~TimeSlicedGeometry()
 {
 
 }
 
 void mitk::TimeSlicedGeometry::SetImageGeometry(const bool isAnImageGeometry)
 {
   Superclass::SetImageGeometry(isAnImageGeometry);
 
   mitk::Geometry3D* geometry3d;
   unsigned int t;
   for(t=0; t<m_TimeSteps; ++t)
   {
     geometry3d = m_Geometry3Ds[t];
     if(geometry3d!=NULL)
       geometry3d->SetImageGeometry(isAnImageGeometry);
   }
 }
 
 
 void mitk::TimeSlicedGeometry::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
 {
   mitk::Geometry3D* geometry3d;
   unsigned int t;
   for(t=0; t<m_TimeSteps; ++t)
   {
     geometry3d = m_Geometry3Ds[t];
     if(geometry3d!=NULL)
       geometry3d->ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
   }
 
   Superclass::ChangeImageGeometryConsideringOriginOffset(isAnImageGeometry);
 }
 
 
 void mitk::TimeSlicedGeometry::SetEvenlyTimed(bool on)
 {
   m_EvenlyTimed = on;
   Modified();
 }
 
 bool mitk::TimeSlicedGeometry::IsValidTime(int t) const
 {
   return (t>=0) && (t< (int)m_TimeSteps);
 }
 
 void mitk::TimeSlicedGeometry::CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t, unsigned int endtimeindex)
 {
   if(endtimeindex >= timeslicedgeometry->GetTimeSteps())
     endtimeindex = timeslicedgeometry->GetTimeSteps()-1;
   if(endtimeindex >= this->GetTimeSteps())
     endtimeindex = this->GetTimeSteps()-1;
   for(; t <= endtimeindex; ++t)
   {
     mitk::Geometry3D* geometry3d = GetGeometry3D(t);
     mitk::Geometry3D* othergeometry3d = timeslicedgeometry->GetGeometry3D(t);
     assert((geometry3d!=NULL) && (othergeometry3d!=NULL));
 
     geometry3d->SetTimeBounds(othergeometry3d->GetTimeBounds());
 
   }
 
   UpdateInformation();
 }
 
 mitk::AffineGeometryFrame3D::Pointer mitk::TimeSlicedGeometry::Clone() const
 {
-  Self::Pointer newGeometry = Self::New();
-  newGeometry->Initialize(m_TimeSteps);
-  InitializeGeometry(newGeometry);
+  Self::Pointer newGeometry = new TimeSlicedGeometry(*this);
   return newGeometry.GetPointer();
 }
 
 void mitk::TimeSlicedGeometry::InitializeGeometry(Self * newGeometry) const
 {
   Superclass::InitializeGeometry(newGeometry);
 
   newGeometry->SetEvenlyTimed(m_EvenlyTimed);
 
   unsigned int t;
   for(t=0; t<m_TimeSteps; ++t)
   {
     if(m_Geometry3Ds[t].IsNull())
     {
       assert(m_EvenlyTimed);
     }
     else
     {
       newGeometry->SetGeometry3D(dynamic_cast<Geometry3D*>(m_Geometry3Ds[t]->Clone().GetPointer()), t);
     }
   }
 }
 
 void mitk::TimeSlicedGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   //Superclass::PrintSelf(os,indent);
   os << indent << " EvenlyTimed: " << m_EvenlyTimed << std::endl;
   os << indent << " TimeSteps: " << m_TimeSteps << std::endl;
 
   os << std::endl;
   os << indent << " GetGeometry3D(0): ";
   if(GetGeometry3D(0)==NULL)
     os << "NULL" << std::endl;
   else
     GetGeometry3D(0)->Print(os, indent);
 }
 
 void mitk::TimeSlicedGeometry::ExecuteOperation(Operation* operation)
 {
   // reach through to all time steps
   for (std::vector<Geometry3D::Pointer>::iterator iter = m_Geometry3Ds.begin();
     iter != m_Geometry3Ds.end();
     ++iter)
   {
     (*iter)->ExecuteOperation(operation);
   }
 
   Geometry3D::ExecuteOperation(operation);
 
   this->Modified();
 }
 
diff --git a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
index 68e273fa55..1cb9f9fde6 100644
--- a/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeSlicedGeometry.h
@@ -1,179 +1,180 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
 #define TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD
 
 #include "mitkGeometry3D.h"
 
 namespace mitk {
 
 //##Documentation
 //## @brief Describes a geometry consisting of several geometries which
 //## exist at different times.
 //##
 //## The geometry contains m_TimeSteps geometries, which can be accessed
 //## using GetGeometry3D(int t). To convert between world-time in
 //## milliseconds and the integer timestep-number use MSToTimeStep.
 //## The hull (in space and time) of the TimeSlicedGeometry contains all
 //## contained geometries.
 //## @warning The hull (i.e., transform, bounding-box and
 //## time-bounds) is only guaranteed to be up-to-date after calling
 //## UpdateInformation().
 //##
 //## TimeSlicedGeometry and the associated Geometry3Ds have to be
 //## initialized in the method GenerateOutputInformation() of BaseProcess (or
 //## CopyInformation/ UpdateOutputInformation of BaseData, if possible, e.g.,
 //## by analyzing pic tags in Image) subclasses. See also
 //## itk::ProcessObject::GenerateOutputInformation(),
 //## itk::DataObject::CopyInformation() and
 //## itk::DataObject::UpdateOutputInformation().
 //##
 //## @ingroup Geometry
 class MITK_CORE_EXPORT TimeSlicedGeometry : public Geometry3D
 {
 public:
   mitkClassMacro(TimeSlicedGeometry, Geometry3D);
 
   itkNewMacro(Self);
 
   //##Documentation
   //## @brief Re-calculate the hull of the contained geometries.
   //##
   //## The transforms, bounding-box and time-bounds of this
   //## geometry (stored in members of the super-class Geometry3D)
   //## are re-calculated from the contained geometries.
   void UpdateInformation();
 
   //##Documentation
   //## @brief Get the number of time-steps
   itkGetConstMacro(TimeSteps, unsigned int);
 
   //##Documentation
   //## @brief Set/Get whether the TimeSlicedGeometry is evenly-timed (m_EvenlyTimed)
   //##
   //## If (a) we don't have a Geometry3D stored for the requested time,
   //## (b) m_EvenlyTimed is activated and (c) the first geometry (t=0)
   //## is set, then we clone the geometry and set the m_TimeBounds accordingly.
   //## \sa GetGeometry3D
    itkGetConstMacro(EvenlyTimed, bool);
   virtual void SetEvenlyTimed(bool on = true);
 
   //##Documentation
   //## @brief Set the Geometry3D for time @a t
   virtual bool SetGeometry3D(mitk::Geometry3D* geometry3D, int t);
 
   //##Documentation
   //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
   virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
 
   //##Documentation
   //## @brief Get the Geometry3D at time @a t
   virtual mitk::Geometry3D* GetGeometry3D(int t) const;
 
   //##Documentation
   //## @brief Test whether @a t is a valid time step
   virtual bool IsValidTime(int t) const;
 
   //##Documentation
   //## @brief Convert time in ms to a time step
   virtual int MSToTimeStep(mitk::ScalarType time_in_ms) const;
 
   //##Documentation
   //## @brief Convert time step to time in ms
   virtual mitk::ScalarType TimeStepToMS(int timestep) const;
 
   //##Documentation
   //## @brief Convert time step in the reference TimeSlicedGeometry to time step
   //## in this TimeSlicedGeometry.
   virtual int TimeStepToTimeStep(const mitk::TimeSlicedGeometry *referenceGeometry, int t) const;
 
   //##Documentation
   //## @brief Completely initialize this instance as evenly-timed with
   //## \a timeSteps geometries of type Geometry3D, each initialized by
   //## Geometry3D::Initialize().
   virtual void Initialize(unsigned int timeSteps);
 
   //##Documentation
   //## @brief Completely initialize this instance as evenly-timed with
   //## \a timeSteps geometries identical to the provided Geometry3D
   //## except for the time bounds
   virtual void InitializeEvenlyTimed(mitk::Geometry3D* geometry3D, unsigned int timeSteps);
 
   //##Documentation
   //## @brief Initialize this instance to contain \a timeSteps
   //## geometries, but without setting them yet
   virtual void InitializeEmpty(unsigned int timeSteps);
 
   //##Documentation
   //## @brief Expand the number of time steps contained
   //## to \a timeSteps.
   //##
   //## New, additional time steps will be initialized empty.
   //## Only enlargement of the time steps vector is intended and possible.
   virtual void ExpandToNumberOfTimeSteps( unsigned int timeSteps );
 
   virtual void SetImageGeometry(const bool isAnImageGeometry);
 
   //##Documentation
   //## @brief Copy the m_TimeBounds of the geometries contained
   //## in timeslicedgeometry into the geometries contained in this
   //## TimeSlicedGeometry object.
   //##
   //## Useful for initialization of the TimeSlicedGeometry of the
   //## output in GenerateOutputInformation() methods of process objects,
   //## see for example BoundingObjectCutter::GenerateOutputInformation().
   //## @param t start time index
   //## @param endtimeindex (endtimeindex) is the time index of
   //## the last geometry whose time-bounds are copied. If
   //## timeslicedgeometry or this TimeSlicedGeometry object does
   //## not contain enough geometries, endtimeindex is reduced
   //## appropriately.
   void CopyTimes(const mitk::TimeSlicedGeometry* timeslicedgeometry, unsigned int t=0, unsigned int endtimeindex = itk::NumericTraits<unsigned int>::max());
 
   //##Documentation
   //## @brief duplicates the geometry
   virtual AffineGeometryFrame3D::Pointer Clone() const;
 
   virtual void ExecuteOperation(Operation* operation);
 protected:
   TimeSlicedGeometry();
+  TimeSlicedGeometry(const TimeSlicedGeometry& other);
 
   virtual ~TimeSlicedGeometry();
 
   void InitializeGeometry(Self * newGeometry) const;
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   mutable std::vector<Geometry3D::Pointer> m_Geometry3Ds;
 
   //##Documentation
   //## @brief Number of time steps
   unsigned int m_TimeSteps;
 
   //##Documentation
   //## @brief \a true in case the time steps have equal length
   bool m_EvenlyTimed;
 
   static const std::string EVENLY_TIMED;
   static const std::string TIME_STEPS;
 };
 
 } // namespace mitk
 
 #endif /* TIMESLICEDGEOMETRY_H_HEADER_INCLUDED_C1EBD0AD */