diff --git a/Core/Code/DataManagement/mitkImageDataItem.cpp b/Core/Code/DataManagement/mitkImageDataItem.cpp
index be046fe7bc..cb81e89d79 100644
--- a/Core/Code/DataManagement/mitkImageDataItem.cpp
+++ b/Core/Code/DataManagement/mitkImageDataItem.cpp
@@ -1,270 +1,270 @@
 /*===================================================================
 
 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 "mitkImageDataItem.h"
 #include "mitkMemoryUtilities.h"
 #include <vtkImageData.h>
 #include <vtkPointData.h>
 
 #include <vtkBitArray.h>
 #include <vtkCharArray.h>
 #include <vtkDoubleArray.h>
 #include <vtkFloatArray.h>
 #include <vtkIntArray.h>
 #include <vtkLongArray.h>
 #include <vtkShortArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkUnsignedIntArray.h>
 #include <vtkUnsignedLongArray.h>
 #include <vtkUnsignedShortArray.h>
 
 #include <mitkImageVtkAccessor.h>
 #include <mitkImage.h>
 
 
 mitk::ImageDataItem::ImageDataItem(const ImageDataItem& aParent, const mitk::ImageDescriptor::Pointer desc, unsigned int dimension, void *data, bool manageMemory, size_t offset) :
   m_Data(NULL), m_ManageMemory(false), m_VtkImageData(NULL), m_Offset(offset), m_IsComplete(false), m_Size(0),
   m_Parent(&aParent)
 {
   m_PixelType = new mitk::PixelType(aParent.GetPixelType());
   m_Data = static_cast<unsigned char*>(aParent.m_Data)+offset;
 
   // compute size
   //const unsigned int *dims = desc->GetDimensions();
   m_Dimension = dimension;
   for( unsigned int i=0; i<dimension; i++)
     m_Dimensions[i] = desc->GetDimensions()[i];
   this->ComputeItemSize(m_Dimensions,dimension);
 
-  if(data != NULL)
+  if(data != NULL && data != m_Data)
   {
     memcpy(m_Data, data, m_Size);
     if(manageMemory)
     {
       delete [] (unsigned char*) data;
     }
   }
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
 }
 
 mitk::ImageDataItem::~ImageDataItem()
 {
   if(m_VtkImageData!=NULL)
     m_VtkImageData->Delete();
   if(m_Parent.IsNull())
   {
     if(m_ManageMemory)
       delete [] m_Data;
   }
   delete m_PixelType;
 }
 
 mitk::ImageDataItem::ImageDataItem(const mitk::ImageDescriptor::Pointer desc, void *data, bool manageMemory)
   : m_Data((unsigned char*)data), m_ManageMemory(manageMemory), m_VtkImageData(NULL), m_Offset(0), m_IsComplete(false), m_Size(0)
 {
   m_PixelType = new mitk::PixelType(desc->GetChannelDescriptor(0).GetPixelType());
 
   // compute size
   const unsigned int *dimensions = desc->GetDimensions();
 
   m_Dimension = desc->GetNumberOfDimensions();
   for( unsigned int i=0; i<m_Dimension; i++)
     m_Dimensions[i] = dimensions[i];
 
   this->ComputeItemSize(m_Dimensions, m_Dimension );
 
   if(m_Data == NULL)
   {
     m_Data = mitk::MemoryUtilities::AllocateElements<unsigned char>( m_Size );
     m_ManageMemory = true;
   }
 
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
 
 }
 
 mitk::ImageDataItem::ImageDataItem(const mitk::PixelType& type, unsigned int dimension, unsigned int *dimensions, void *data, bool manageMemory) :
   m_Data((unsigned char*)data), m_ManageMemory(manageMemory), m_VtkImageData(NULL), m_Offset(0), m_IsComplete(false), m_Size(0),
   m_Parent(NULL)
 {
   m_PixelType = new mitk::PixelType(type);
 
   m_Dimension = dimension;
   for( unsigned int i=0; i<m_Dimension; i++)
     m_Dimensions[i] = dimensions[i];
 
   this->ComputeItemSize(dimensions, dimension);
 
   if(m_Data == NULL)
   {
     m_Data = mitk::MemoryUtilities::AllocateElements<unsigned char>( m_Size );
     m_ManageMemory = true;
   }
 
   m_ReferenceCountLock.Lock();
   m_ReferenceCount = 0;
   m_ReferenceCountLock.Unlock();
 }
 
 mitk::ImageDataItem::ImageDataItem(const ImageDataItem &other)
   : itk::LightObject(), m_PixelType(other.m_PixelType), m_ManageMemory(other.m_ManageMemory), m_Offset(other.m_Offset),
     m_IsComplete(other.m_IsComplete), m_Size(other.m_Size)
 {
 
 }
 
 void mitk::ImageDataItem::ComputeItemSize(const unsigned int *dimensions, unsigned int dimension)
 {
   m_Size = m_PixelType->GetSize();
   for( unsigned int i=0; i<dimension; i++)
   {
     m_Size *= *(dimensions+i);
   }
 }
 
 void mitk::ImageDataItem::ConstructVtkImageData(ImagePointer iP) const
 {
   mitk::ImageVtkAccessor *inData = ImageVtkAccessor::New(iP,this); //vtkImageData::New();
   vtkDataArray *scalars = NULL;
 
   const unsigned int *dims = m_Dimensions;
   const unsigned int dim = m_Dimension;
 
   unsigned long size = 0;
   if ( dim == 1 )
   {
     inData->SetDimensions( dims[0] -1, 1, 1);
     size = dims[0];
     inData->SetOrigin( ((mitk::ScalarType) dims[0]) / 2.0, 0, 0 );
   }
   else
   if ( dim == 2 )
   {
     inData->SetDimensions( dims[0] , dims[1] , 1 );
     size = dims[0] * dims[1];
     inData->SetOrigin( ((mitk::ScalarType) dims[0]) / 2.0f, ((mitk::ScalarType) dims[1]) / 2.0f, 0 );
   }
   else
   if ( dim >= 3 )
   {
     inData->SetDimensions( dims[0], dims[1], dims[2] );
     size = dims[0] * dims[1] * dims[2];
     // Test
     //inData->SetOrigin( (float) dims[0] / 2.0f, (float) dims[1] / 2.0f, (float) dims[2] / 2.0f );
     inData->SetOrigin( 0, 0, 0 );
   }
   else
   {
     inData->Delete () ;
     return;
   }
 
   int datatype;
 
 /*  if ( ( m_PixelType.GetType() == mitkIpPicInt || m_PixelType.GetType() == mitkIpPicUInt ) && m_PixelType.GetBitsPerComponent() == 1 )
   {
     datatype = VTK_BIT );
     scalars = vtkBitArray::New();
   }
   else*/ if ( m_PixelType->GetComponentType() == itk::ImageIOBase::CHAR )
   {
     datatype = VTK_CHAR;
     scalars = vtkCharArray::New();
   }
   else if (   m_PixelType->GetComponentType() == itk::ImageIOBase::UCHAR)
   {
     datatype = VTK_UNSIGNED_CHAR;
     scalars = vtkUnsignedCharArray::New();
   }
   else if (  m_PixelType->GetComponentType() == itk::ImageIOBase::SHORT )
   {
     datatype = VTK_SHORT;
     scalars = vtkShortArray::New();
   }
   else if (   m_PixelType->GetComponentType() == itk::ImageIOBase::USHORT )
   {
     datatype = VTK_UNSIGNED_SHORT;
     scalars = vtkUnsignedShortArray::New();
   }
   else if (  m_PixelType->GetComponentType() == itk::ImageIOBase::INT )
   {
     datatype = VTK_INT;
     scalars = vtkIntArray::New();
   }
   else if (   m_PixelType->GetComponentType() == itk::ImageIOBase::UINT )
   {
     datatype = VTK_UNSIGNED_INT;
     scalars = vtkUnsignedIntArray::New();
   }
   else if ( m_PixelType->GetComponentType() == itk::ImageIOBase::LONG )
   {
     datatype = VTK_LONG;
     scalars = vtkLongArray::New();
   }
   else if (  m_PixelType->GetComponentType() == itk::ImageIOBase::ULONG )
   {
     datatype = VTK_UNSIGNED_LONG;
     scalars = vtkUnsignedLongArray::New();
   }
   else if (  m_PixelType->GetComponentType() == itk::ImageIOBase::FLOAT  )
   {
     datatype = VTK_FLOAT;
     scalars = vtkFloatArray::New();
   }
   else if (  m_PixelType->GetComponentType() == itk::ImageIOBase::DOUBLE  )
   {
     datatype = VTK_DOUBLE;
     scalars = vtkDoubleArray::New();
   }
   else
   {
     inData->Delete();
     return;
   }
 
   inData->AllocateScalars(datatype,m_PixelType->GetNumberOfComponents());
 
   m_VtkImageData = inData;
 
   // allocate the new scalars
   scalars->SetNumberOfComponents(m_VtkImageData->GetNumberOfScalarComponents());
 
   scalars->SetVoidArray(m_Data, size * m_VtkImageData->GetNumberOfScalarComponents(), 1);
 
   m_VtkImageData->GetPointData()->SetScalars(scalars);
   scalars->Delete();
 
 }
 
 void mitk::ImageDataItem::Modified() const
 {
   if(m_VtkImageData)
     m_VtkImageData->Modified();
 }
 
 
 mitk::ImageVtkAccessor* mitk::ImageDataItem::GetVtkImageData(mitk::ImagePointer iP) const
 {
   if(m_VtkImageData==NULL)
     ConstructVtkImageData(iP);
   return m_VtkImageData;
 }
 
diff --git a/Core/Code/DataManagement/mitkPropertyList.cpp b/Core/Code/DataManagement/mitkPropertyList.cpp
index 94278f7332..dea0cbf441 100644
--- a/Core/Code/DataManagement/mitkPropertyList.cpp
+++ b/Core/Code/DataManagement/mitkPropertyList.cpp
@@ -1,284 +1,285 @@
 /*===================================================================
 
 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 "mitkPropertyList.h"
 
 #include "mitkProperties.h"
 #include "mitkStringProperty.h"
 #include "mitkVector.h"
 
 
 mitk::BaseProperty* mitk::PropertyList::GetProperty(const std::string& propertyKey) const
 {
     PropertyMap::const_iterator it;
 
     it=m_Properties.find( propertyKey );
     if(it!=m_Properties.end())
       return it->second;
     else
         return NULL;
 }
 
 
 void mitk::PropertyList::SetProperty(const std::string& propertyKey, BaseProperty* property)
 {
   if (!property) return;
   //make sure that BaseProperty*, which may have just been created and never been
   //assigned to a SmartPointer, is registered/unregistered properly. If we do not
   //do that, it will a) not deleted in case it is identical to the old one or
   //b) possibly deleted when temporarily added to a smartpointer somewhere below.
   BaseProperty::Pointer tmpSmartPointerToProperty = property;
 
   PropertyMap::iterator it( m_Properties.find( propertyKey ) );
 
   // Is a property with key @a propertyKey contained in the list?
   if( it != m_Properties.end() )
   {
     // yes
     //is the property contained in the list identical to the new one?
     if( it->second->operator==(*property) )
     {
       // yes? do nothing and return.
       return;
     }
 
     if (it->second->AssignProperty(*property))
     {
       // The assignment was successfull
       this->Modified();
     }
     else
     {
       MITK_ERROR << "In " __FILE__ ", l." << __LINE__
                  << ": Trying to set existing property " << it->first << " of type " << it->second->GetNameOfClass()
                  << " to a property with different type " << property->GetNameOfClass() << "."
                  << " Use ReplaceProperty() instead."
                  << std::endl;
     }
     return;
   }
 
   //no? add it.
   PropertyMapElementType newProp;
   newProp.first = propertyKey;
   newProp.second = property;
   m_Properties.insert ( newProp );
   this->Modified();
 }
 
 
 void mitk::PropertyList::ReplaceProperty(const std::string& propertyKey, BaseProperty* property)
 {
   if (!property) return;
 
   PropertyMap::iterator it( m_Properties.find( propertyKey ) );
 
   // Is a property with key @a propertyKey contained in the list?
   if( it != m_Properties.end() )
   {
     it->second=NULL;
     m_Properties.erase(it);
   }
 
   //no? add/replace it.
   PropertyMapElementType newProp;
   newProp.first = propertyKey;
   newProp.second = property;
   m_Properties.insert ( newProp );
   Modified();
 }
 
 
 mitk::PropertyList::PropertyList()
 {
 }
 
 mitk::PropertyList::PropertyList(const mitk::PropertyList& other)
   : itk::Object()
 {
   for (PropertyMap::const_iterator i = other.m_Properties.begin();
        i != other.m_Properties.end(); ++i)
   {
     m_Properties.insert(std::make_pair(i->first, i->second->Clone()));
   }
 }
 
 
 mitk::PropertyList::~PropertyList()
 {
   Clear();
 }
 
 
 /**
  * Consider the list as changed when any of the properties has changed recently.
  */
 unsigned long mitk::PropertyList::GetMTime() const
 {
   for ( PropertyMap::const_iterator it = m_Properties.begin() ;
         it != m_Properties.end();
         ++it )
   {
     if( it->second.IsNull() )
     {
       itkWarningMacro(<< "Property '" << it->first <<"' contains nothing (NULL).");
       continue;
     }
     if( Superclass::GetMTime() < it->second->GetMTime() )
     {
       Modified();
       break;
     }
   }
 
   return Superclass::GetMTime();
 }
 
 
 bool mitk::PropertyList::DeleteProperty(const std::string& propertyKey)
 {
   PropertyMap::iterator it;
   it=m_Properties.find( propertyKey );
 
   if(it!=m_Properties.end())
   {
     it->second=NULL;
     m_Properties.erase(it);
     Modified();
     return true;
   }
   return false;
 }
 
 
 void mitk::PropertyList::Clear()
 {
   PropertyMap::iterator it = m_Properties.begin(), end = m_Properties.end();
   while(it!=end)
   {
     it->second = NULL;
     ++it;
   }
   m_Properties.clear();
 }
 
 itk::LightObject::Pointer mitk::PropertyList::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
+  result->UnRegister();
   return result;
 }
 
 void mitk::PropertyList::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   if (pList)
   {
     const PropertyMap* propertyMap = pList->GetMap();
 
     for ( PropertyMap::const_iterator iter = propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
           iter != propertyMap->end();
           ++iter )
     {
       const std::string key = iter->first;
       BaseProperty* value = iter->second;
       if (replace)
       {
         ReplaceProperty( key.c_str(), value );
       }
       else
       {
         SetProperty( key.c_str(), value );
       }
     }
   }
 }
 
 bool mitk::PropertyList::GetBoolProperty(const char* propertyKey, bool& boolValue) const
 {
   BoolProperty *gp = dynamic_cast<BoolProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     boolValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<bool>(propertyKey, boolValue);
 }
 
 
 bool mitk::PropertyList::GetIntProperty(const char* propertyKey, int &intValue) const
 {
   IntProperty *gp = dynamic_cast<IntProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     intValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<int>(propertyKey, intValue);
 }
 
 
 bool mitk::PropertyList::GetFloatProperty(const char* propertyKey, float &floatValue) const
 {
   FloatProperty *gp = dynamic_cast<FloatProperty*>( GetProperty(propertyKey) );
   if ( gp != NULL )
   {
     floatValue = gp->GetValue();
     return true;
   }
   return false;
   // Templated Method does not work on Macs
   //return GetPropertyValue<float>(propertyKey, floatValue);
 }
 
 
 bool mitk::PropertyList::GetStringProperty(const char* propertyKey, std::string& stringValue) const
 {
   StringProperty* sp= dynamic_cast<StringProperty*>(GetProperty(propertyKey));
   if ( sp != NULL )
   {
     stringValue = sp->GetValue();
     return true;
   }
   return false;
 }
 
 
 void mitk::PropertyList::SetIntProperty(const char* propertyKey, int intValue)
 {
   SetProperty(propertyKey, mitk::IntProperty::New(intValue));
 }
 
 
 void mitk::PropertyList::SetBoolProperty( const char* propertyKey, bool boolValue)
 {
   SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
 }
 
 
 void mitk::PropertyList::SetFloatProperty( const char* propertyKey, float floatValue)
 {
   SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
 }
 
 
 void mitk::PropertyList::SetStringProperty( const char* propertyKey, const char* stringValue)
 {
   SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
 }