diff --git a/Core/Code/DataManagement/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index a3393b30f1..83b8cceb1d 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,362 +1,371 @@
 /*===================================================================
 
 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 "mitkBaseData.h"
 #include <itkObjectFactoryBase.h>
 
 
 #define MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
 
 mitk::BaseData::BaseData() :
   m_RequestedRegionInitialized(false), m_SmartSourcePointer(NULL),
   m_SourceOutputIndexDuplicate(0), m_Initialized(true),
   m_Unregistering(false), m_CalculatingExternalReferenceCount(false),
   m_ExternalReferenceCount(-1)
 {
   m_TimeSlicedGeometry = TimeSlicedGeometry::New();
   m_PropertyList = PropertyList::New();
 }
 
 mitk::BaseData::BaseData( const BaseData &other ):
 itk::DataObject(), mitk::OperationActor(),
 m_RequestedRegionInitialized(other.m_RequestedRegionInitialized),
 m_SmartSourcePointer(other.m_SmartSourcePointer),
 m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
 m_Initialized(other.m_Initialized), m_Unregistering(other.m_Unregistering),
 m_CalculatingExternalReferenceCount(other.m_CalculatingExternalReferenceCount),
 m_ExternalReferenceCount(other.m_ExternalReferenceCount)
 {
   m_TimeSlicedGeometry = dynamic_cast<mitk::TimeSlicedGeometry*>(other.m_TimeSlicedGeometry->Clone().GetPointer());
   m_PropertyList = other.m_PropertyList->Clone();
 }
 
 mitk::BaseData::~BaseData()
 {
   m_SmartSourcePointer = NULL;
 }
 
 void mitk::BaseData::InitializeTimeSlicedGeometry(unsigned int timeSteps)
 {
   mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
 
   mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
   g3d->Initialize();
 
  if ( timeSteps > 1 )
  {
     mitk::ScalarType timeBounds[] = {0.0, 1.0};
     g3d->SetTimeBounds( timeBounds );
  }
 
   // The geometry is propagated automatically to the other items,
   // if EvenlyTimed is true...
   timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
 }
 
 void mitk::BaseData::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
   if(m_TimeSlicedGeometry.IsNotNull())
     m_TimeSlicedGeometry->UpdateInformation();
 }
 
 const mitk::TimeSlicedGeometry* mitk::BaseData::GetUpdatedTimeSlicedGeometry()
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetTimeSlicedGeometry();
 }
 
+const mitk::TimeGeometry* mitk::BaseData::GetUpdatedTimeGeometry()
+{
+  SetRequestedRegionToLargestPossibleRegion();
+
+  UpdateOutputInformation();
+
+  return GetTimeGeometry();
+}
+
 void mitk::BaseData::Expand( unsigned int timeSteps )
 {
   if( m_TimeSlicedGeometry.IsNotNull() )
     m_TimeSlicedGeometry->ExpandToNumberOfTimeSteps( timeSteps );
 }
 
 const mitk::Geometry3D* mitk::BaseData::GetUpdatedGeometry(int t)
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetGeometry(t);
 }
 
 void mitk::BaseData::SetGeometry(Geometry3D* aGeometry3D)
 {
 if(aGeometry3D!=NULL)
   {
     TimeSlicedGeometry::Pointer timeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(aGeometry3D);
     if ( timeSlicedGeometry.IsNotNull() )
       m_TimeSlicedGeometry = timeSlicedGeometry;
     else
     {
       timeSlicedGeometry = TimeSlicedGeometry::New();
       m_TimeSlicedGeometry = timeSlicedGeometry;
       timeSlicedGeometry->InitializeEvenlyTimed(aGeometry3D, 1);
     }
     Modified();
   }
   else if( m_TimeSlicedGeometry.IsNotNull() )
   {
     m_TimeSlicedGeometry = NULL;
     Modified();
   }
   return;
 }
 
 void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D)
 {
   SetGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()));
 }
 
 void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time)
 {
   if (m_TimeSlicedGeometry)
   {
     m_TimeSlicedGeometry->SetGeometry3D(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()), time);
   }
 }
 
 bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
 {
   return IsInitialized() == false;
 }
 
 bool mitk::BaseData::IsEmpty() const
 {
   if(IsInitialized() == false)
     return true;
   const TimeSlicedGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeSlicedGeometry();
   if(timeGeometry == NULL)
     return true;
   unsigned int timeSteps = timeGeometry->GetTimeSteps();
   for ( unsigned int t = 0 ; t < timeSteps ; ++t )
   {
     if(IsEmptyTimeStep(t) == false)
       return false;
   }
   return true;
 }
 
 itk::SmartPointer<mitk::BaseProcess> mitk::BaseData::GetSource() const
 {
   return static_cast<mitk::BaseProcess*>(Superclass::GetSource().GetPointer());
 }
 
 int mitk::BaseData::GetExternalReferenceCount() const
 {
   if(m_CalculatingExternalReferenceCount==false) //this is only needed because a smart-pointer to m_Outputs (private!!) must be created by calling GetOutputs.
   {
     m_CalculatingExternalReferenceCount = true;
 
     m_ExternalReferenceCount = -1;
 
     int realReferenceCount = GetReferenceCount();
 
     if(GetSource().IsNull())
     {
       m_ExternalReferenceCount = realReferenceCount;
       m_CalculatingExternalReferenceCount = false;
       return m_ExternalReferenceCount;
     }
 
     mitk::BaseProcess::DataObjectPointerArray outputs = m_SmartSourcePointer->GetOutputs();
 
     unsigned int idx;
     for (idx = 0; idx < outputs.size(); ++idx)
     {
       //references of outputs that are not referenced from someone else (reference additional to the reference from this BaseProcess object) are interpreted as non-existent
       if(outputs[idx]==this)
         --realReferenceCount;
     }
     m_ExternalReferenceCount = realReferenceCount;
     if(m_ExternalReferenceCount<0)
       m_ExternalReferenceCount=0;
     m_CalculatingExternalReferenceCount = false;
   }
   else
     return -1;
   return m_ExternalReferenceCount;
 }
 
 void mitk::BaseData::UnRegister() const
 {
 #ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
   if(GetReferenceCount()>1)
   {
     Superclass::UnRegister();
     if((m_Unregistering==false) && (m_SmartSourcePointer.IsNotNull()))
     {
       m_Unregistering=true;
       // the order of the following boolean statement is important:
       // this->GetSource() returns a SmartPointer,
       // which increases and afterwards decreases the reference count,
       // which may result in an ExternalReferenceCount of 0, causing
       // BaseProcess::UnRegister() to destroy us (also we already
       // about to do that).
       if((this->m_SmartSourcePointer->GetExternalReferenceCount()==0) || (this->GetSource().IsNull()))
         m_SmartSourcePointer=NULL; // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
       else
         m_Unregistering=false;
     }
   }
   else
 #endif
     Superclass::UnRegister(); // now the reference count is zero and this object has been destroyed; thus nothing may be done after this line!!
 }
 
 void mitk::BaseData::ConnectSource(itk::ProcessObject *arg, unsigned int idx) const
 {
 #ifdef MITK_WEAKPOINTER_PROBLEM_WORKAROUND_ENABLED
   itkDebugMacro( "connecting source  " << arg
     << ", source output index " << idx);
 
   if ( GetSource().GetPointer() != arg || m_SourceOutputIndexDuplicate != idx)
   {
     m_SmartSourcePointer = dynamic_cast<mitk::BaseProcess*>(arg);
     m_SourceOutputIndexDuplicate = idx;
     Modified();
   }
 #endif
 }
 
 mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 
 mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void mitk::BaseData::SetProperty(const char *propertyKey,
                                  BaseProperty* propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::BaseData::SetPropertyList(PropertyList *pList)
 {
   m_PropertyList = pList;
 }
 
 void mitk::BaseData::SetOrigin(const mitk::Point3D& origin)
 {
   mitk::TimeSlicedGeometry* timeSlicedGeometry = GetTimeSlicedGeometry();
 
   assert(timeSlicedGeometry!=NULL);
 
   mitk::Geometry3D* geometry;
 
   unsigned int steps = timeSlicedGeometry->GetTimeSteps();
 
   for(unsigned int timestep = 0; timestep < steps; ++timestep)
   {
     geometry = GetGeometry(timestep);
     if(geometry != NULL)
     {
       geometry->SetOrigin(origin);
     }
     if(GetTimeSlicedGeometry()->GetEvenlyTimed())
     {
       GetTimeSlicedGeometry()->InitializeEvenlyTimed(geometry, steps);
       break;
     }
   }
 }
 
 unsigned long mitk::BaseData::GetMTime() const
 {
   unsigned long time = Superclass::GetMTime();
   if(m_TimeSlicedGeometry.IsNotNull())
   {
     if((time < m_TimeSlicedGeometry->GetMTime()))
     {
       Modified();
       return Superclass::GetMTime();
     }
     //unsigned long geometryTime = m_TimeSlicedGeometry->GetMTime();
     //if(time < geometryTime)
     //{
     //  return geometryTime;
     //}
   }
   return time;
 }
 
 void mitk::BaseData::CopyInformation( const itk::DataObject* data )
 {
   const Self* bd = dynamic_cast<const Self*>(data);
   if (bd != NULL)
   {
     m_TimeSlicedGeometry = dynamic_cast<TimeSlicedGeometry*>(bd->GetTimeSlicedGeometry()->Clone().GetPointer());
     m_PropertyList = bd->GetPropertyList()->Clone();
   }
   else
   {
     // pointer could not be cast back down; this can be the case if your filters input
     // and output objects differ in type; then you have to write your own GenerateOutputInformation method
     itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast "
       << typeid(data).name() << " to "
       << typeid(Self*).name() );
   }
 
 }
 
 bool mitk::BaseData::IsInitialized() const
 {
   return m_Initialized;
 }
 
 void mitk::BaseData::Clear()
 {
   this->ClearData();
   this->InitializeEmpty();
 }
 
 void mitk::BaseData::ClearData()
 {
   if(m_Initialized)
   {
     ReleaseData();
     m_Initialized = false;
   }
 }
 
 void mitk::BaseData::ExecuteOperation(mitk::Operation* /*operation*/)
 {
   //empty by default. override if needed!
 }
 
 void mitk::BaseData::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << std::endl;
   os << indent << " TimeSlicedGeometry: ";
   if(GetTimeSlicedGeometry() == NULL)
     os << "NULL" << std::endl;
   else
     GetTimeSlicedGeometry()->Print(os, indent);
 }
 
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index 73ff102752..955c0331d5 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,388 +1,403 @@
 /*===================================================================
 
 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 BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 #define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 
 #include <itkDataObject.h>
 
 #include "mitkBaseProcess.h"
-#include "mitkTimeSlicedGeometry.h"
+#include "mitkTimeGeometry.h"
 #include <MitkExports.h>
 #include "mitkOperationActor.h"
 #include "mitkPropertyList.h"
 
+//To be replaced
+#include "mitkTimeSlicedGeometry.h"
+
 
 namespace mitk {
 
 //class BaseProcess;
 
 //##Documentation
 //## @brief Base of all data objects
 //##
 //## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
 //## from itk::DataObject and thus can be included in a pipeline.
 //## Inherits also from OperationActor and can be used as a destination for Undo
 //## @ingroup Data
 class MITK_CORE_EXPORT BaseData : public itk::DataObject, public OperationActor
 {
 public:
   mitkClassMacro(BaseData,itk::DataObject)
 
   //##Documentation
   //## @brief Return the TimeSlicedGeometry of the data as const pointer.
   //##
   //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   //## be sure that the geometry is up-to-date.
   //##
   //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   const mitk::TimeSlicedGeometry* GetTimeSlicedGeometry() const
   {
     return m_TimeSlicedGeometry.GetPointer();
   }
 
+  const mitk::TimeGeometry* GetTimeGeometry() const
+  {
+    return m_TimeGeometry.GetPointer();
+  }
+
   //##Documentation
   //## @brief Return the TimeSlicedGeometry of the data as pointer.
   //##
   //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   //## be sure that the geometry is up-to-date.
   //##
   //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   mitk::TimeSlicedGeometry* GetTimeSlicedGeometry()
   {
     return m_TimeSlicedGeometry.GetPointer();
   }
 
+  mitk::TimeGeometry* GetTimeGeometry()
+  {
+    return m_TimeGeometry.GetPointer();
+  }
+
   //##Documentation
   //## @brief Return the Geometry3D of the data.
   //##
   //## The method does not simply return the value of the m_TimeSlicedGeometry
   //## member. Before doing this, it makes sure that the TimeSlicedGeometry
   //## is up-to-date (by setting the update extent to largest possible and
   //## calling UpdateOutputInformation).
   const mitk::TimeSlicedGeometry* GetUpdatedTimeSlicedGeometry();
+  const mitk::TimeGeometry* GetUpdatedTimeGeometry();
 
   //##Documentation
   //## @brief Expands the TimeSlicedGeometry to a number of TimeSteps.
   //##
   //## The method expands the TimeSlicedGeometry to the given number of TimeSteps,
   //## filling newly created elements with empty geometries. Sub-classes should override
   //## this method to handle the elongation of their data vectors, too.
   //## Note that a shrinking is neither possible nor intended.
   virtual void Expand( unsigned int timeSteps );
 
   //##Documentation
   //## @brief Return the Geometry3D of the data at time \a t.
   //##
   //## The method does not simply return
   //## m_TimeSlicedGeometry->GetGeometry(t).
   //## Before doing this, it makes sure that the Geometry3D is up-to-date
   //## (by setting the update extent appropriately and calling
   //## UpdateOutputInformation).
   //##
   //## @todo Appropriate setting of the update extent is missing.
   const mitk::Geometry3D* GetUpdatedGeometry(int t=0);
 
   //##Documentation
   //## @brief Return the geometry, which is a TimeSlicedGeometry, of the data
   //## as non-const pointer.
   //##
   //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
   //## be sure that the geometry is up-to-date.
   //##
   //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
   mitk::Geometry3D* GetGeometry(int t=0) const
   {
     if(m_TimeSlicedGeometry.IsNull())
       return NULL;
     return m_TimeSlicedGeometry->GetGeometry3D(t);
   }
 
   //##Documentation
   //## @brief Helps to deal with the weak-pointer-problem.
   virtual void UnRegister() const;
 
   //##Documentation
   //## @brief for internal use only. Helps to deal with the
   //## weak-pointer-problem.
   virtual int GetExternalReferenceCount() const;
 
   //##Documentation
   //## @brief Update the information for this BaseData (the geometry in particular)
   //## so that it can be used as an output of a BaseProcess.
   //##
   //## This method is used in the pipeline mechanism to propagate information and
   //## initialize the meta data associated with a BaseData. Any implementation
   //## of this method in a derived class is assumed to call its source's
   //## BaseProcess::UpdateOutputInformation() which determines modified
   //## times, LargestPossibleRegions, and any extra meta data like spacing,
   //## origin, etc. Default implementation simply call's it's source's
   //## UpdateOutputInformation().
   //## \note Implementations of this methods in derived classes must take care
   //## that the geometry is updated by calling
   //## GetTimeSlicedGeometry()->UpdateInformation()
   //## \em after calling its source's BaseProcess::UpdateOutputInformation().
   void UpdateOutputInformation();
 
   //##Documentation
   //## @brief Set the RequestedRegion to the LargestPossibleRegion.
   //##
   //## This forces a filter to produce all of the output in one execution
   //## (i.e. not streaming) on the next call to Update().
   void SetRequestedRegionToLargestPossibleRegion()=0;
 
   //##Documentation
   //## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
   //##
   //## This method returns true if the RequestedRegion
   //## is outside the BufferedRegion (true if at least one pixel is
   //## outside). This is used by the pipeline mechanism to determine
   //## whether a filter needs to re-execute in order to satisfy the
   //## current request.  If the current RequestedRegion is already
   //## inside the BufferedRegion from the previous execution (and the
   //## current filter is up to date), then a given filter does not need
   //## to re-execute
   bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
 
   //##Documentation
   //## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
   //##
   //## If the RequestedRegion is not within the LargestPossibleRegion,
   //## then the filter cannot possibly satisfy the request. This method
   //## returns true if the request can be satisfied (even if it will be
   //## necessary to process the entire LargestPossibleRegion) and
   //## returns false otherwise.  This method is used by
   //## PropagateRequestedRegion().  PropagateRequestedRegion() throws a
   //## InvalidRequestedRegionError exception if the requested region is
   //## not within the LargestPossibleRegion.
   virtual bool VerifyRequestedRegion() = 0;
 
   //##Documentation
   //## @brief Copy information from the specified data set.
   //##
   //## This method is part of the pipeline execution model. By default, a
   //## BaseProcess will copy meta-data from the first input to all of its
   //## outputs. See ProcessObject::GenerateOutputInformation().  Each
   //## subclass of DataObject is responsible for being able to copy
   //## whatever meta-data it needs from another DataObject.
   //## The default implementation of this method copies the time sliced geometry
   //## and the property list of an object. If a subclass overrides this
   //## method, it should always call its superclass' version.
   void CopyInformation(const itk::DataObject* data);
 
   //##Documentation
   //## @brief Check whether the data has been initialized, i.e.,
   //## at least the Geometry and other header data has been set
   //##
   //## \warning Set to \a true by default for compatibility reasons.
   //## Set m_Initialized=false in constructors of sub-classes that
   //## support distinction between initialized and uninitialized state.
   virtual bool IsInitialized() const;
 
   //##Documentation
   //## @brief Calls ClearData() and InitializeEmpty();
   //## \warning Only use in subclasses that reimplemented these methods.
   //## Just calling Clear from BaseData will reset an object to a not initialized,
   //## invalid state.
   virtual void Clear();
 
   //##Documentation
   //## @brief Check whether object contains data (at
   //## a specified time), e.g., a set of points may be empty
   //##
   //## \warning Returns IsInitialized()==false by default for
   //## compatibility reasons. Override in sub-classes that
   //## support distinction between empty/non-empty state.
   virtual bool IsEmptyTimeStep(unsigned int t) const;
 
   //##Documentation
   //## @brief Check whether object contains data (at
   //## least at one point in time), e.g., a set of points
   //## may be empty
   //##
   //## \warning Returns IsInitialized()==false by default for
   //## compatibility reasons. Override in sub-classes that
   //## support distinction between empty/non-empty state.
   virtual bool IsEmpty() const;
 
   //##Documentation
   //## @brief Set the requested region from this data object to match the requested
   //## region of the data object passed in as a parameter.
   //##
   //## This method is implemented in the concrete subclasses of BaseData.
   void SetRequestedRegion(itk::DataObject *data)=0;
 
   //##Documentation
   //##@brief overwrite if the Data can be called by an Interactor (StateMachine).
   //##
   //## Empty by default. Overwrite and implement all the necessary operations here
   //## and get the necessary information from the parameter operation.
   void ExecuteOperation(Operation* operation);
 
   //##Documentation
   //## @brief Set the Geometry3D of the data, which will be referenced (not copied!).
   //## Assumes the data object has only 1 time step ( is a 3D object ).
   //##
   //## For convenience (and historic) reasons, it is also possible to set a complete
   //## mitk::TimeSlicedGeometry*, which will be referenced (not copied!).
   //##
   //## @warning This method will normally be called internally by the sub-class of BaseData
   //## during initialization.
   //## \sa SetClonedGeometry
   virtual void SetGeometry(Geometry3D* aGeometry3D);
 
   //##Documentation
   //## @brief Set a clone of the provided geometry as Geometry3D of the data.
   //## Assumes the data object has only 1 time step ( is a 3D object )
   //##
   //## \sa SetGeometry
   virtual void SetClonedGeometry(const Geometry3D* aGeometry3D);
 
   //##Documentation
   //## @brief Set a clone of the provided geometry as Geometry3D of a given time step.
   //##
   //## \sa SetGeometry
   virtual void SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time);
 
   //##Documentation
   //## @brief Get the data's property list
   //## @sa GetProperty
   //## @sa m_PropertyList
   mitk::PropertyList::Pointer GetPropertyList() const;
 
   //##Documentation
   //## @brief Set the data's property list
   //## @sa SetProperty
   //## @sa m_PropertyList
   void SetPropertyList(PropertyList* propertyList);
 
   //##Documentation
   //## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
   //## and set it to this, respectively;
   //## @sa GetPropertyList
   //## @sa m_PropertyList
   //## @sa m_MapOfPropertyLists
   mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
 
   void SetProperty(const char *propertyKey, BaseProperty* property);
 
   //##Documentation
   //## @brief Convenience method for setting the origin of
   //## the Geometry3D instances of all time steps
   //##
   //## \warning Geometries contained in the Geometry3D will
   //## \em not be changed, e.g. in case the Geometry3D is a
   //## SlicedGeometry3D the origin will \em not be propagated
   //## to the contained slices. The sub-class SlicedData
   //## does this for the case that the SlicedGeometry3D is
   //## evenly spaced.
   virtual void SetOrigin(const Point3D& origin);
 
   /** \brief Get the process object that generated this data object.
    *
    * If there is no process object, then the data object has
    * been disconnected from the pipeline, or the data object
    * was created manually. (Note: we cannot use the GetObjectMacro()
    * defined in itkMacro because the mutual dependency of
    * DataObject and ProcessObject causes compile problems. Also,
    * a forward reference smart pointer is returned, not a smart pointer,
    * because of the circular dependency between the process and data object.)
    *
    * GetSource() returns a SmartPointer and not a WeakPointer
    * because it is assumed the code calling GetSource() wants to hold a
    * long term reference to the source. */
   itk::SmartPointer<mitk::BaseProcess> GetSource() const;
 
   //##Documentation
   //## @brief Get the number of time steps from the Timeslicedgeometry
   //## As the base data has not a data vector given by itself, the number
   //## of time steps is defined over the time sliced geometry. In sub classes,
   //## a better implementation could be over the length of the data vector.
   unsigned int GetTimeSteps() const
   {
     return m_TimeSlicedGeometry->GetTimeSteps();
   }
 
 
   //##Documentation
   //## @brief Get the modified time of the last change of the contents
   //## this data object or its geometry.
   virtual unsigned long GetMTime() const;
 
 protected:
   BaseData();
   BaseData(const BaseData &other);
   ~BaseData();
 
   //##Documentation
   //## @brief Initialize the TimeSlicedGeometry for a number of time steps.
   //## The TimeSlicedGeometry is initialized empty and evenly timed.
   //## In many cases it will be necessary to overwrite this in sub-classes.
   virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
 
   //##Documentation
   //## @brief reset to non-initialized state, release memory
   virtual void ClearData();
 
   //##Documentation
   //## @brief Pure virtual; Must be used in subclasses to get a data object to a
   //## valid state. Should at least create one empty object and call
   //## Superclass::InitializeTimeSlicedGeometry() to ensure an existing valid geometry
   virtual void InitializeEmpty(){}
 
 
   virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
   bool m_RequestedRegionInitialized;
   bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
 
   mutable itk::SmartPointer<mitk::BaseProcess> m_SmartSourcePointer;
   mutable unsigned int m_SourceOutputIndexDuplicate;
   //##Documentation
   //## @brief for internal use only. Helps to deal with the
   //## weak-pointer-problem.
   virtual void ConnectSource(itk::ProcessObject *arg, unsigned int idx) const;
 
   bool m_Initialized;
 
 private:
   //##Documentation
   //## @brief Helps to deal with the weak-pointer-problem.
   mutable bool m_Unregistering;
   //##Documentation
   //## @brief Helps to deal with the weak-pointer-problem.
   mutable bool m_CalculatingExternalReferenceCount;
   //##Documentation
   //## @brief Helps to deal with the weak-pointer-problem.
   mutable int m_ExternalReferenceCount;
 
   //##Documentation
   //## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
   //##
   PropertyList::Pointer m_PropertyList;
 
   TimeSlicedGeometry::Pointer m_TimeSlicedGeometry;
+  TimeGeometry::Pointer m_TimeGeometry;
 
   //##Documentation
   //## @brief Helps to deal with the weak-pointer-problem.
   friend class mitk::BaseProcess;
 };
 
 } // namespace mitk
 
 
 #endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkBaseGeometry.h b/Core/Code/DataManagement/mitkBaseGeometry.h
index b1c97ec669..893e9ab2e8 100644
--- a/Core/Code/DataManagement/mitkBaseGeometry.h
+++ b/Core/Code/DataManagement/mitkBaseGeometry.h
@@ -1,59 +1,68 @@
 /*===================================================================
 
 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 BaseGeometry_h
 #define BaseGeometry_h
 
 //MITK
 #include <MitkExports.h>
 #include <mitkCommon.h>
 #include "mitkOperationActor.h"
 #include "mitkVector.h"
 
 // To be replaced
 #include <mitkSlicedGeometry3D.h>
 
 // STL
 #include <vector>
 
 //ITK
 #include <itkBoundingBox.h>
 #include <itkFixedArray.h>
 #include <itkObject.h>
 
 namespace mitk {
 
 
   class MITK_CORE_EXPORT BaseGeometry : public itk::Object, public OperationActor
   {
 
   public:
+    mitkClassMacro(BaseGeometry, itk::Object);
+
     virtual void Transform( Transform3D& transformation )
     {};
+    //##Documentation
+    //## @brief Get the position of a corner (in world coordinates)
+    //##
+    //## See SetImageGeometry for how a corner is defined on images.
+    Point3D GetCornerPointInWorldSpace(bool xFront=true, bool yFront=true, bool zFront=true) const
+    {return m_Geo->GetCornerPoint(xFront,yFront,zFront);}
+
 
     mitk::Geometry3D::Pointer m_Geo;
 
 
   protected:
 
     BaseGeometry();
     virtual ~BaseGeometry();
 
     BoundingBox::Pointer m_BoundingBox;
   }; // end class BaseGeometry
 
 } // end namespace MITK
 #endif // BaseGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
new file mode 100644
index 0000000000..4d20a01011
--- /dev/null
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -0,0 +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.
+
+===================================================================*/
+#include <mitkProportionalTimeGeometry.h>
+
+mitk::ProportionalTimeGeometry::ProportionalTimeGeometry()
+{
+}
+
+mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
+{
+}
+
+void mitk::ProportionalTimeGeometry::Initialize()
+{
+}
+
+mitk::ProportionalTimeGeometry::TimeStepType mitk::ProportionalTimeGeometry::GetNumberOfTimeSteps ()
+{
+  return static_cast<TimeStepType>(m_GeometryVector.size() );
+}
+
+mitk::ProportionalTimeGeometry::TimePointType mitk::ProportionalTimeGeometry::GetMinimumTimePoint ()
+{
+  return m_FirstTimePoint;
+}
+
+mitk::ProportionalTimeGeometry::TimePointType mitk::ProportionalTimeGeometry::GetMaximumTimePoint ()
+{
+  return m_FirstTimePoint + m_StepDuration + GetNumberOfTimeSteps();
+}
+
+mitk::TimeBounds mitk::ProportionalTimeGeometry::GetTimeBounds ()
+{
+  TimeBounds bounds;
+  bounds[0] = this->GetMinimumTimePoint();
+  bounds[1] = this->GetMaximumTimePoint();
+  return bounds;
+}
+
+bool mitk::ProportionalTimeGeometry::IsValidTimePoint (TimePointType& timePoint)
+{
+  return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
+}
+
+bool mitk::ProportionalTimeGeometry::IsValidTimeStep (TimeStepType& timeStep)
+{
+  return 0 <= timeStep && timeStep <  this->GetNumberOfTimeSteps();
+}
+
+mitk::ProportionalTimeGeometry::TimePointType mitk::ProportionalTimeGeometry::TimeStepToTimePoint( TimeStepType& timeStep)
+{
+  return m_FirstTimePoint + timeStep * m_StepDuration;
+}
+
+mitk::ProportionalTimeGeometry::TimeStepType mitk::ProportionalTimeGeometry::TimePointToTimeStep( TimePointType& timePoint)
+{
+  assert(timePoint >= m_FirstTimePoint);
+  return static_cast<TimeStepType>((timePoint -m_FirstTimePoint) / m_StepDuration);
+}
+
+mitk::BaseGeometry* mitk::ProportionalTimeGeometry::GetGeometryForTimeStep( TimeStepType timeStep)
+{
+  return dynamic_cast<BaseGeometry*>(m_GeometryVector[timeStep].GetPointer());
+}
+
+mitk::BaseGeometry* mitk::ProportionalTimeGeometry::GetGeometryForTimePoint(TimePointType timePoint)
+{
+  TimeStepType timeStep = this->TimePointToTimeStep(timePoint);
+  return this->GetGeometryForTimeStep(timeStep);
+}
+
+bool mitk::ProportionalTimeGeometry::IsValid()
+{
+  bool isValid = true;
+  isValid &= m_GeometryVector.size() > 0;
+  isValid &= m_StepDuration > 0;
+  return isValid;
+}
+
+void mitk::ProportionalTimeGeometry::ExecuteOperation(mitk::Operation* operation)
+{
+}
+
+void mitk::ProportionalTimeGeometry::ClearAllGeometries()
+{
+  m_GeometryVector.clear();
+}
+
+void mitk::ProportionalTimeGeometry::ReserveSpaceForGeometries(TimeStepType numberOfGeometries)
+{
+  m_GeometryVector.reserve(numberOfGeometries);
+}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.h b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
new file mode 100644
index 0000000000..c950f8ce19
--- /dev/null
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
@@ -0,0 +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 ProportialTimeGeometry_h
+#define ProportialTimeGeometry_h
+
+//MITK
+#include <mitkTimeGeometry.h>
+#include <mitkBaseGeometry.h>
+#include <mitkCommon.h>
+#include <MitkExports.h>
+#include "mitkOperationActor.h"
+#include "mitkVector.h"
+
+// To be replaced
+#include <mitkSlicedGeometry3D.h>
+
+// STL
+#include <vector>
+
+//ITK
+#include <itkBoundingBox.h>
+#include <itkFixedArray.h>
+#include <itkObject.h>
+
+namespace mitk {
+
+//  typedef itk::BoundingBox<unsigned long, 3, double>   BoundingBox;
+//  typedef itk::FixedArray<ScalarType,2>                TimeBounds;
+
+  class MITK_CORE_EXPORT ProportionalTimeGeometry : public TimeGeometry
+  {
+  public:
+
+    ProportionalTimeGeometry();
+//    mitkClassMacro(ProportionalTimeGeometry, TimeGeometry);
+    typedef ProportionalTimeGeometry self;
+    itkNewMacro(self);
+
+    virtual TimeStepType     GetNumberOfTimeSteps();
+    virtual TimePointType    GetMinimumTimePoint ();
+    virtual TimePointType    GetMaximumTimePoint ();
+
+    //##Documentation
+    //## @brief Get the time bounds (in ms)
+    virtual TimeBounds GetTimeBounds( );
+
+    virtual bool IsValidTimePoint (TimePointType& timePoint);
+    virtual bool IsValidTimeStep  (TimeStepType& timeStep);
+    virtual TimePointType  TimeStepToTimePoint (TimeStepType& timeStep);
+    virtual TimeStepType   TimePointToTimeStep (TimePointType& timePoint);
+
+    virtual BaseGeometry* GetGeometryForTimePoint ( TimePointType timePoint);
+    virtual BaseGeometry* GetGeometryForTimeStep  ( TimeStepType timeStep);
+
+    virtual bool IsValid ();
+
+    virtual void Initialize();
+
+    virtual void ExecuteOperation(Operation *);
+
+    itkGetMacro(FirstTimePoint, TimePointType);
+    itkSetMacro(FirstTimePoint, TimePointType);
+    itkGetMacro(StepDuration, TimePointType);
+    itkSetMacro(StepDuration, TimePointType);
+
+//    void SetGeometryForTimeStep(TimeStepType timeStep, BaseGeometry& geometry);
+    void ClearAllGeometries ();
+//    void AddGeometry(BaseGeometry geometry);
+    void ReserveSpaceForGeometries (TimeStepType numberOfGeometries);
+
+  protected:
+    virtual ~ProportionalTimeGeometry();
+
+    BoundingBox::Pointer m_BoundingBox;
+    std::vector<BaseGeometry::Pointer> m_GeometryVector;
+    TimePointType m_FirstTimePoint;
+    TimePointType m_StepDuration;
+
+  }; // end class ProportialTimeGeometry
+
+} // end namespace MITK
+#endif // ProportialTimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
index 0173d8f129..52042bb798 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -1,101 +1,122 @@
 /*===================================================================
 
 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 <mitkTimeGeometry.h>
 
 mitk::TimeGeometry::TimeGeometry()
 {
 }
 
 mitk::TimeGeometry::~TimeGeometry()
 {
 }
 
 void mitk::TimeGeometry::Initialize()
 {
 }
 
+
+/* \brief short description
+ * parameters
+ *
+ */
 mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorldSpace(int id) const
 {
   assert(id >= 0);
   assert(m_BoundingBox.IsNotNull());
 
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   switch(id)
   {
     case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
     case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
     case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
     case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
     case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
     case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
     case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
     case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
     default:
       {
         itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
         return NULL;
       }
   }
 
   // TimeGeometry has no Transformation. Therefore the bounding box
   // contains all data in world coordinates
   return cornerpoint;
 }
 
 mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorldSpace(bool xFront, bool yFront, bool zFront) const
 {
   assert(m_BoundingBox.IsNotNull());
   BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
 
   Point3D cornerpoint;
   cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
   cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
   cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
 
   return cornerpoint;
 }
 
 mitk::Point3D mitk::TimeGeometry::GetCenterInWorldSpace() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_BoundingBox->GetCenter();
 }
 
 double mitk::TimeGeometry::GetDiagonalLength2InWorldSpace() const
 {
   Vector3D diagonalvector = GetCornerPointInWorldSpace()-GetCornerPointInWorldSpace(false, false, false);
   return diagonalvector.GetSquaredNorm();
 }
 
 double mitk::TimeGeometry::GetDiagonalLengthinWorldSpace() const
 {
   return sqrt(GetDiagonalLength2InWorldSpace());
 }
 
 bool mitk::TimeGeometry::IsWorldPointInside(const mitk::Point3D& p) const
 {
   return m_BoundingBox->IsInside(p);
 }
 
 void mitk::TimeGeometry::ApplyTransformMatrixToAllTimeSteps (mitk::Transform3D& transformation)
 {
   for (TimeStepType step = 0; step <GetNumberOfTimeSteps(); ++step)
   {
     GetGeometryForTimeStep(step)->Transform(transformation);
   }
 }
+
+void mitk::TimeGeometry::UpdateBoundingBox ()
+{
+  assert(m_BoundingBox.IsNotNull());
+  typedef BoundingBox::PointsContainer ContainerType;
+
+  ContainerType::Pointer points = ContainerType::New();
+  points->reserve(2*GetNumberOfTimeSteps());
+  for (TimeStepType step = 0; step <GetNumberOfTimeSteps(); ++step)
+  {
+    points->push_back(GetGeometryForTimeStep(step)->GetCornerPointInWorldSpace(false,false,false));
+    points->push_back(GetGeometryForTimeStep(step)->GetCornerPointInWorldSpace(true,true,true));
+  }
+  m_BoundingBox->SetPoints(points);
+  m_BoundingBox->ComputeBoundingBox();
+}
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.h b/Core/Code/DataManagement/mitkTimeGeometry.h
index 2278890c36..8eb2c93bef 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeGeometry.h
@@ -1,120 +1,170 @@
 /*===================================================================
 
 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 TimeGeometry_h
 #define TimeGeometry_h
 
+//ITK
+#include <itkBoundingBox.h>
+#include <itkFixedArray.h>
+#include <itkObject.h>
 //MITK
 #include <mitkBaseGeometry.h>
 #include <mitkCommon.h>
 #include <MitkExports.h>
 #include "mitkOperationActor.h"
 #include "mitkVector.h"
 
 // To be replaced
 #include <mitkSlicedGeometry3D.h>
 
 // STL
 #include <vector>
 
-//ITK
-#include <itkBoundingBox.h>
-#include <itkFixedArray.h>
-#include <itkObject.h>
 
 namespace mitk {
 
 //  typedef itk::BoundingBox<unsigned long, 3, double>   BoundingBox;
 //  typedef itk::FixedArray<ScalarType,2>                TimeBounds;
 
+  /**
+  * \brief Manages the geometries of a data object for each time step
+  *
+  * For each time step a geometry object is kept, which defines
+  * the position and transformation of the BasicObject.
+  */
   class MITK_CORE_EXPORT TimeGeometry : public itk::Object, public OperationActor
   {
 
   public:
+    mitkClassMacro(TimeGeometry, itk::Object);
+
     typedef unsigned long TimePointType;
     typedef std::size_t   TimeStepType;
 
-    virtual TimeStepType GetNumberOfTimeSteps() = 0;
+    /**
+    * \brief Returns the number of time steps.
+    */
+    virtual TimeStepType     GetNumberOfTimeSteps() = 0;
+    /**
+    * \brief Returns the first time point for which the object is valid.
+    */
     virtual TimePointType    GetMinimumTimePoint () = 0;
+    /**
+    * \brief Returns the last time point for which the object is valid
+    */
     virtual TimePointType    GetMaximumTimePoint () = 0;
 
-    //##Documentation
-    //## @brief Get the time bounds (in ms)
+    /**
+    * \brief Get the time bounds (in ms)
+    */
     virtual TimeBounds GetTimeBounds( ) = 0;
-
+    /**
+    * \brief Tests if a given time point is covered by this object
+    */
     virtual bool IsValidTimePoint (TimePointType& timePoint) = 0;
+    /**
+    * \brief Test for the given time step if a geometry is availible
+    */
     virtual bool IsValidTimeStep  (TimeStepType& timeStep) = 0;
 
+    /**
+    * \brief Converts a time step to a time point
+    */
     virtual TimePointType  TimeStepToTimePoint (TimeStepType& timeStep) = 0;
+    /**
+    * \brief Converts a time point to the corresponding time step
+    */
     virtual TimeStepType   TimePointToTimeStep (TimePointType& timePoint) = 0;
 
-    virtual BaseGeometry* GetGeometryForTimePoint ( TimePointType& timePoint) = 0;
-    virtual BaseGeometry* GetGeometryForTimeStep  ( TimeStepType& timeStep) = 0;
-
-    // To be implemented by this class
+    /**
+    * \brief Returns the geometry of a specific time point
+    */
+    virtual BaseGeometry* GetGeometryForTimePoint ( TimePointType timePoint) = 0;
+    /**
+    * \brief Returns the geometry which corresponds to the given time step
+    */
+    virtual BaseGeometry* GetGeometryForTimeStep  ( TimeStepType timeStep) = 0;
+
+    /**
+    * \brief Applies the given transformation to all time
+    */
     void ApplyTransformMatrixToAllTimeSteps (Transform3D& transformation);
 
+    /**
+    * \brief Tests if all necessary informations are set and the object is valid
+    */
     virtual bool IsValid () = 0;
-    //##Documentation
-    //## @brief Get the position of the corner number \a id (in world coordinates)
-    //##
-    //## See SetImageGeometry for how a corner is defined on images.
+    /**
+    * \brief Get the position of the corner number \a id (in world coordinates)
+    *
+    * See SetImageGeometry for how a corner is defined on images.
+    */
     Point3D GetCornerPointInWorldSpace(int id) const;
 
-    //##Documentation
-    //## @brief Get the position of a corner (in world coordinates)
-    //##
-    //## See SetImageGeometry for how a corner is defined on images.
+    /**
+    * \brief Get the position of a corner (in world coordinates)
+    *
+    * See SetImageGeometry for how a corner is defined on images.
+    */
     Point3D GetCornerPointInWorldSpace(bool xFront=true, bool yFront=true, bool zFront=true) const;
 
-    //##Documentation
-    //## @brief Get the center of the bounding-box in mm
-    //##
+    /**
+    * \brief Get the center of the bounding-box in mm
+    */
     Point3D GetCenterInWorldSpace() const;
 
-    //##Documentation
-    //## @brief Get the squared length of the diagonal of the bounding-box in mm
-    //##
+    /**
+    * \brief Get the squared length of the diagonal of the bounding-box in mm
+    */
     double GetDiagonalLength2InWorldSpace() const;
 
-    //##Documentation
-    //## @brief Get the length of the diagonal of the bounding-box in mm
-    //##
+    /**
+    * \brief Get the length of the diagonal of the bounding-box in mm
+    */
     double GetDiagonalLengthinWorldSpace() const;
 
-    //##Documentation
-    //## @brief Test whether the point \a p (world coordinates in mm) is
-    //## inside the bounding box
+    /**
+    * \brief Test whether the point \a p (world coordinates in mm) is inside the bounding box
+    */
     bool IsWorldPointInside(const mitk::Point3D& p) const;
 
-    //##Documentation
-    //## @brief Updates the bounding box to cover the area used in all time steps
-    //##
-    //## The bounding box is updated by this method. The new bounding box
-    //## covers an area which includes all bounding boxes during
-    //## all times steps.
-    virtual void UpdateBoundingBox() = 0;
-
+    /**
+    * \brief Updates the bounding box to cover the area used in all time steps
+    *
+    * The bounding box is updated by this method. The new bounding box
+    * covers an area which includes all bounding boxes during
+    * all times steps.
+    */
+    void UpdateBoundingBox();
+
+    /**
+    * \brief Initializes the TimeGeometry
+    */
     virtual void Initialize();
   protected:
     TimeGeometry();
     virtual ~TimeGeometry();
 
+    /**
+    * \brief Contains a bounding box which includes all time steps
+    */
     BoundingBox::Pointer m_BoundingBox;
+
   }; // end class TimeGeometry
 
 } // end namespace MITK
 #endif // TimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index 33a723b687..bd0238c74c 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,364 +1,366 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkLocalVariationImageFilter.h
   Algorithms/itkLocalVariationImageFilter.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/itkTotalVariationDenoisingImageFilter.h
   Algorithms/itkTotalVariationDenoisingImageFilter.txx
   Algorithms/itkTotalVariationSingleIterationImageFilter.h
   Algorithms/itkTotalVariationSingleIterationImageFilter.txx
   Algorithms/mitkBilateralFilter.h
   Algorithms/mitkBilateralFilter.cpp
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   # Preprocessor macros taken from Boost
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
   Algorithms/mitkPlaneClipping.h
 
   Common/mitkExceptionMacro.h
   Common/mitkServiceBaseObject.h
   Common/mitkTestingMacros.h
 
+  DataManagement/mitkProportionalTimeGeometry.h
   DataManagement/mitkTimeGeometry.h
   DataManagement/mitkBaseGeometry.h
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkImageToItk.txx
 
   Interactions/mitkEventMapperAddOn.h
 
   Interfaces/mitkIDataNodeReader.h
 
   IO/mitkPixelTypeTraits.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkBaseProcess.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCoreActivator.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
+  DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
   #DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataNodeFactory.cpp
   #DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkGeometry2D.cpp
   DataManagement/mitkGeometry2DData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkLandmarkBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeSlicedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 #  Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 #  Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
 
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
 
   IO/mitkBaseDataIOFactory.cpp
   IO/mitkCoreDataNodeReader.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileSeriesReader.cpp
   IO/mitkFileWriter.cpp
   #IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkImageWriter.cpp
   IO/mitkImageWriterFactory.cpp
   IO/mitkItkImageFileIOFactory.cpp
   IO/mitkItkImageFileReader.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkItkPictureWrite.cpp
   IO/mitkIOUtil.cpp
   IO/mitkLookupTableProperty.cpp
   IO/mitkOperation.cpp
   #IO/mitkPicFileIOFactory.cpp
   #IO/mitkPicFileReader.cpp
   #IO/mitkPicFileWriter.cpp
   #IO/mitkPicHelper.cpp
   #IO/mitkPicVolumeTimeSeriesIOFactory.cpp
   #IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetIOFactory.cpp
   IO/mitkPointSetReader.cpp
   IO/mitkPointSetWriter.cpp
   IO/mitkPointSetWriterFactory.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSTLFileIOFactory.cpp
   IO/mitkSTLFileReader.cpp
   IO/mitkSurfaceVtkWriter.cpp
   IO/mitkSurfaceVtkWriterFactory.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkVtiFileIOFactory.cpp
   IO/mitkVtiFileReader.cpp
   IO/mitkVtkImageIOFactory.cpp
   IO/mitkVtkImageReader.cpp
   IO/mitkVtkSurfaceIOFactory.cpp
   IO/mitkVtkSurfaceReader.cpp
   IO/vtkPointSetXMLParser.cpp
   IO/mitkLog.cpp
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkGeometry2DDataMapper2D.cpp
   Rendering/mitkGeometry2DDataVtkMapper3D.cpp
   Rendering/mitkGLMapper.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetGLMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkPolyDataGLMapper2D.cpp
   Rendering/mitkSurfaceGLMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkShaderRepository.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
   Rendering/mitkRenderingTestHelper.cpp
 
   Common/mitkException.cpp
   Common/mitkCommon.h
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 )
 
 list(APPEND CPP_FILES ${CppMicroServices_SOURCES})
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 Shaders/mitkShaderLighting.xml
 
 mitkLevelWindowPresets.xml
 )