diff --git a/Core/Code/DataManagement/mitkAnnotationProperty.cpp b/Core/Code/DataManagement/mitkAnnotationProperty.cpp
index 64e425329e..f47fff0e7c 100644
--- a/Core/Code/DataManagement/mitkAnnotationProperty.cpp
+++ b/Core/Code/DataManagement/mitkAnnotationProperty.cpp
@@ -1,118 +1,118 @@
 /*===================================================================
 
 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 "mitkAnnotationProperty.h"
 
-mitk::AnnotationProperty::AnnotationProperty()
+mitk::AnnotationProperty::AnnotationProperty() : m_Position(0.0)
 {
 }
 
 
 mitk::AnnotationProperty::AnnotationProperty(
   const char *label, const Point3D &position )
 : m_Label( "" ),
   m_Position( position )
 {
   if ( label != NULL )
   {
     m_Label = label;
   }
 }
 
 
 mitk::AnnotationProperty::AnnotationProperty(
   const std::string &label, const Point3D &position )
 : m_Label( label ),
   m_Position( position )
 {
 }
 
 
 mitk::AnnotationProperty::AnnotationProperty(
   const char *label, ScalarType x, ScalarType y, ScalarType z )
 : m_Label( "" )
 {
   if ( label != NULL )
   {
     m_Label = label;
   }
 
   m_Position[0] = x;
   m_Position[1] = y;
   m_Position[2] = z;
 }
 
 
 mitk::AnnotationProperty::AnnotationProperty(
   const std::string &label, ScalarType x, ScalarType y, ScalarType z )
 : m_Label( label )
 {
   m_Position[0] = x;
   m_Position[1] = y;
   m_Position[2] = z;
 }
 
 mitk::AnnotationProperty::AnnotationProperty(const mitk::AnnotationProperty& other)
   : BaseProperty(other)
   , m_Label(other.m_Label)
   , m_Position(other.m_Position)
 {
 }
 
 const mitk::Point3D &mitk::AnnotationProperty::GetPosition() const
 {
   return m_Position;
 }
 
 
 void mitk::AnnotationProperty::SetPosition( const mitk::Point3D &position )
 {
   if (m_Position != position)
   {
     m_Position = position;
     this->Modified();
   }
 }
 
 
 bool mitk::AnnotationProperty::IsEqual( const BaseProperty &property ) const
 {
   return ( (this->m_Label == static_cast<const Self&>(property).m_Label )
            && (this->m_Position == static_cast<const Self&>(property).m_Position ) );
 }
 
 bool mitk::AnnotationProperty::Assign( const BaseProperty &property )
 {
   this->m_Label = static_cast<const Self&>(property).m_Label;
   this->m_Position = static_cast<const Self&>(property).m_Position;
   return true;
 }
 
 
 std::string mitk::AnnotationProperty::GetValueAsString() const
 {
   std::stringstream myStr;
 
   myStr << this->GetLabel() << this->GetPosition();
   return myStr.str();
 }
 
 itk::LightObject::Pointer mitk::AnnotationProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
diff --git a/Core/Code/DataManagement/mitkClippingProperty.cpp b/Core/Code/DataManagement/mitkClippingProperty.cpp
index ff2c3bd66d..bf6f1bbe06 100644
--- a/Core/Code/DataManagement/mitkClippingProperty.cpp
+++ b/Core/Code/DataManagement/mitkClippingProperty.cpp
@@ -1,125 +1,125 @@
 /*===================================================================
 
 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 "mitkClippingProperty.h"
 
 
 namespace mitk
 {
 
 ClippingProperty::ClippingProperty()
-: m_ClippingEnabled( false )
+    : m_ClippingEnabled( false ), m_Origin(0.0), m_Normal(0.0)
 {
 }
 
 ClippingProperty::ClippingProperty(const ClippingProperty& other)
   : BaseProperty(other)
   , m_ClippingEnabled(other.m_ClippingEnabled)
   , m_Origin(other.m_Origin)
   , m_Normal(other.m_Normal)
 {
 }
 
 ClippingProperty::ClippingProperty(
   const Point3D &origin, const Vector3D &normal )
 : m_ClippingEnabled( true ),
   m_Origin( origin ),
   m_Normal( normal )
 {
 }
 
 
 bool ClippingProperty::GetClippingEnabled() const
 {
   return m_ClippingEnabled;
 }
 
 
 void ClippingProperty::SetClippingEnabled( bool enabled )
 {
   if (m_ClippingEnabled != enabled)
   {
     m_ClippingEnabled = enabled;
     this->Modified();
   }
 }
 
 
 const Point3D &ClippingProperty::GetOrigin() const
 {
   return m_Origin;
 }
 
 
 void ClippingProperty::SetOrigin( const Point3D &origin )
 {
   if (m_Origin != origin)
   {
     m_Origin = origin;
     this->Modified();
   }
 }
 
 
 const Vector3D &ClippingProperty::GetNormal() const
 {
   return m_Normal;
 }
 
 
 void ClippingProperty::SetNormal( const Vector3D &normal )
 {
   if (m_Normal != normal)
   {
     m_Normal = normal;
     this->Modified();
   }
 }
 
 
 bool ClippingProperty::IsEqual( const BaseProperty &property ) const
 {
   return ((this->m_ClippingEnabled == static_cast<const Self&>(property).m_ClippingEnabled) &&
           (this->m_Origin == static_cast<const Self&>(property).m_Origin ) &&
           (this->m_Normal == static_cast<const Self&>(property).m_Normal ) );
 }
 
 bool ClippingProperty::Assign( const BaseProperty &property )
 {
   this->m_ClippingEnabled = static_cast<const Self&>(property).m_ClippingEnabled;
   this->m_Origin = static_cast<const Self&>(property).m_Origin;
   this->m_Normal = static_cast<const Self&>(property).m_Normal;
   return true;
 }
 
 std::string ClippingProperty::GetValueAsString() const
 {
   std::stringstream myStr;
 
   myStr << this->GetClippingEnabled() << this->GetOrigin() << this->GetNormal();
   return myStr.str();
 }
 
 itk::LightObject::Pointer ClippingProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
 
 
 } // namespace
 
diff --git a/Core/Code/DataManagement/mitkColorProperty.cpp b/Core/Code/DataManagement/mitkColorProperty.cpp
index c5675294ad..108dd82f68 100644
--- a/Core/Code/DataManagement/mitkColorProperty.cpp
+++ b/Core/Code/DataManagement/mitkColorProperty.cpp
@@ -1,99 +1,99 @@
 /*===================================================================
 
 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 <sstream>
 #include "mitkColorProperty.h"
 
 mitk::ColorProperty::ColorProperty()
-: m_Color()
+: m_Color(0.0f)
 {
 
 }
 
 mitk::ColorProperty::ColorProperty(const mitk::ColorProperty& other)
   : BaseProperty(other)
   , m_Color(other.m_Color)
 {
 }
 
 mitk::ColorProperty::ColorProperty(const float color[3]) : m_Color(color)
 {
 
 }
 
 mitk::ColorProperty::ColorProperty(const float red, const float green, const float blue)
 {
   m_Color.Set(red, green, blue);
 }
 
 mitk::ColorProperty::ColorProperty(const mitk::Color & color) : m_Color(color)
 {
 
 }
 
 bool mitk::ColorProperty::IsEqual(const BaseProperty& property) const
 {
   return this->m_Color == static_cast<const Self&>(property).m_Color;
 }
 
 bool mitk::ColorProperty::Assign(const BaseProperty& property)
 {
   this->m_Color = static_cast<const Self&>(property).m_Color;
   return true;
 }
 
 const mitk::Color & mitk::ColorProperty::GetColor() const
 {
     return m_Color;
 }
 
 void mitk::ColorProperty::SetColor(const mitk::Color & color )
 {
     if(m_Color!=color)
     {
         m_Color = color;
         Modified();
     }
 }
 
 void mitk::ColorProperty::SetValue(const mitk::Color & color )
 {
   SetColor(color);
 }
 
 void mitk::ColorProperty::SetColor( float red, float green, float blue )
 {
   float tmp[3] = { red, green, blue };
   SetColor(mitk::Color(tmp));
 }
 
 std::string mitk::ColorProperty::GetValueAsString() const {
   std::stringstream myStr;
   myStr.imbue(std::locale::classic());
   myStr << GetValue() ;
   return myStr.str();
 }
 const mitk::Color & mitk::ColorProperty::GetValue() const
 {
     return GetColor();
 }
 
 itk::LightObject::Pointer mitk::ColorProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
diff --git a/Core/Code/DataManagement/mitkTransferFunction.cpp b/Core/Code/DataManagement/mitkTransferFunction.cpp
index e7afe33229..d3b6b29abc 100644
--- a/Core/Code/DataManagement/mitkTransferFunction.cpp
+++ b/Core/Code/DataManagement/mitkTransferFunction.cpp
@@ -1,332 +1,332 @@
 /*===================================================================
 
 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 "mitkTransferFunction.h"
 #include "mitkImageToItk.h"
 #include "mitkHistogramGenerator.h"
 
 #include <itkRGBPixel.h>
 
 #include <vector>
 
 namespace mitk
 {
 
 
-TransferFunction::TransferFunction()
+TransferFunction::TransferFunction() : m_Min(0), m_Max(0)
 {
   m_ScalarOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
   m_ColorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
   m_GradientOpacityFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
 
   m_ScalarOpacityFunction->Initialize();
   m_ScalarOpacityFunction->AddPoint(0,1);
 
   m_GradientOpacityFunction->Initialize();
   m_GradientOpacityFunction->AddPoint(0,1);
 
   m_ColorTransferFunction->RemoveAllPoints();
   m_ColorTransferFunction->SetColorSpaceToHSV();
   m_ColorTransferFunction->AddRGBPoint(0,1,1,1);
 }
 
 TransferFunction::TransferFunction(const TransferFunction& other)
   : itk::Object()
   , m_ScalarOpacityFunction(other.m_ScalarOpacityFunction.New())
   , m_GradientOpacityFunction(other.m_GradientOpacityFunction.New())
   , m_ColorTransferFunction(other.m_ColorTransferFunction.New())
   , m_Min(other.m_Min)
   , m_Max(other.m_Max)
   , m_Histogram(other.m_Histogram)
   , m_ScalarOpacityPoints(other.m_ScalarOpacityPoints)
   , m_GradientOpacityPoints(other.m_GradientOpacityPoints)
   , m_RGBPoints(other.m_RGBPoints)
 {
   m_ScalarOpacityFunction->DeepCopy(other.m_ScalarOpacityFunction);
   m_GradientOpacityFunction->DeepCopy(other.m_GradientOpacityFunction);
   m_ColorTransferFunction->DeepCopy(other.m_ColorTransferFunction);
 }
 
 TransferFunction::~TransferFunction()
 {
 }
 
 bool TransferFunction::operator==(Self& other)
 {
   if ((m_Min != other.m_Min) || (m_Max != other.m_Max))
     return false;
 
   bool sizes = (m_ScalarOpacityFunction->GetSize() == other.m_ScalarOpacityFunction->GetSize())
             && (m_GradientOpacityFunction->GetSize() == other.m_GradientOpacityFunction->GetSize())
             && (m_ColorTransferFunction->GetSize() == other.m_ColorTransferFunction->GetSize());
   if (sizes == false)
     return false;
 
   for (int i = 0; i < m_ScalarOpacityFunction->GetSize(); i++ )
   {
     double myVal[4];
     double otherVal[4];
     m_ScalarOpacityFunction->GetNodeValue(i, myVal);
     other.m_ScalarOpacityFunction->GetNodeValue(i, otherVal);
     bool equal = (myVal[0] == otherVal[0])
               && (myVal[1] == otherVal[1])
               && (myVal[2] == otherVal[2])
               && (myVal[3] == otherVal[3]);
     if (equal == false)
       return false;
   }
   for (int i = 0; i < m_GradientOpacityFunction->GetSize(); i++ )
   {
     double myVal[4];
     double otherVal[4];
     m_GradientOpacityFunction->GetNodeValue(i, myVal);
     other.m_GradientOpacityFunction->GetNodeValue(i, otherVal);
     bool equal = (myVal[0] == otherVal[0])
       && (myVal[1] == otherVal[1])
       && (myVal[2] == otherVal[2])
       && (myVal[3] == otherVal[3]);
     if (equal == false)
       return false;
   }
   for (int i = 0; i < m_ColorTransferFunction->GetSize(); i++ )
   {
     double myVal[6];
     double otherVal[6];
     m_ColorTransferFunction->GetNodeValue(i, myVal);
     other.m_ColorTransferFunction->GetNodeValue(i, otherVal);
     bool equal = (myVal[0] == otherVal[0]) // X
       && (myVal[1] == otherVal[1])  // R
       && (myVal[2] == otherVal[2])  // G
       && (myVal[3] == otherVal[3])  // B
       && (myVal[4] == otherVal[4])  // midpoint
       && (myVal[5] == otherVal[5]); // sharpness
     if (equal == false)
       return false;
   }
   return true;
 }
 
 void TransferFunction::SetScalarOpacityPoints(TransferFunction::ControlPoints points)
 {
   m_ScalarOpacityFunction->RemoveAllPoints();
   for(unsigned int i=0; i<=points.size()-1;i++)
   {
     this->AddScalarOpacityPoint(points[i].first, points[i].second);
   }
 }
 
 
 void TransferFunction::SetGradientOpacityPoints(TransferFunction::ControlPoints points)
 {
   m_GradientOpacityFunction->RemoveAllPoints();
   for(unsigned int i=0; i<=points.size()-1;i++)
   {
     this->AddGradientOpacityPoint(points[i].first, points[i].second);
   }
 }
 
 
 void TransferFunction::SetRGBPoints(TransferFunction::RGBControlPoints rgbpoints)
 {
   m_ColorTransferFunction->RemoveAllPoints();
   for(unsigned int i=0; i<=rgbpoints.size()-1;i++)
   {
     this->AddRGBPoint(rgbpoints[i].first, rgbpoints[i].second[0],
       rgbpoints[i].second[1], rgbpoints[i].second[2]);
   }
 }
 
 void TransferFunction::AddScalarOpacityPoint(double x, double value)
 {
   m_ScalarOpacityFunction->AddPoint(x, value);
 }
 
 
 void TransferFunction::AddGradientOpacityPoint(double x, double value)
 {
   m_GradientOpacityFunction->AddPoint(x, value);
 }
 
 
 void TransferFunction::AddRGBPoint(double x, double r, double g, double b)
 {
   m_ColorTransferFunction->AddRGBPoint(x, r, g, b);
 }
 
 
 TransferFunction::ControlPoints &TransferFunction::GetScalarOpacityPoints()
 {
   // Retrieve data points from VTK transfer function and store them in a vector
   m_ScalarOpacityPoints.clear();
   double *data = m_ScalarOpacityFunction->GetDataPointer();
   for ( int i = 0; i < m_ScalarOpacityFunction->GetSize(); ++i )
   {
     m_ScalarOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
   }
 
   return m_ScalarOpacityPoints;
 }
 
 
 TransferFunction::ControlPoints &TransferFunction::GetGradientOpacityPoints()
 {
   // Retrieve data points from VTK transfer function and store them in a vector
   m_GradientOpacityPoints.clear();
   double *data = m_GradientOpacityFunction->GetDataPointer();
   for ( int i = 0; i < m_GradientOpacityFunction->GetSize(); ++i )
   {
     m_GradientOpacityPoints.push_back( std::make_pair( data[i*2], data[i*2+1] ));
   }
 
   return m_GradientOpacityPoints;
 }
 
 
 TransferFunction::RGBControlPoints &TransferFunction::GetRGBPoints()
 {
   // Retrieve data points from VTK transfer function and store them in a vector
   m_RGBPoints.clear();
   double *data = m_ColorTransferFunction->GetDataPointer();
   for ( int i = 0; i < m_ColorTransferFunction->GetSize(); ++i )
   {
     double rgb[] = { data[i*4+1], data[i*4+2], data[i*4+3] };
     m_RGBPoints.push_back( std::make_pair( data[i*4], rgb ));
   }
 
   return m_RGBPoints;
 }
 
 
 int TransferFunction::RemoveScalarOpacityPoint(double x)
 {
   return m_ScalarOpacityFunction->RemovePoint(x);
 }
 
 
 int TransferFunction::RemoveGradientOpacityPoint(double x)
 {
   return m_GradientOpacityFunction->RemovePoint(x);
 }
 
 
 int TransferFunction::RemoveRGBPoint(double x)
 {
   return m_ColorTransferFunction->RemovePoint(x);
 }
 
 
 void TransferFunction::ClearScalarOpacityPoints()
 {
   m_ScalarOpacityFunction->RemoveAllPoints();
 }
 
 
 void TransferFunction::ClearGradientOpacityPoints()
 {
   m_GradientOpacityFunction->RemoveAllPoints();
 }
 
 
 void TransferFunction::ClearRGBPoints()
 {
   m_ColorTransferFunction->RemoveAllPoints();
 }
 
 
 void TransferFunction::InitializeByItkHistogram(
   const itk::Statistics::Histogram<double>* histogram)
 {
   m_Histogram = histogram;
   m_Min = (int)GetHistogram()->GetBinMin(0,0);
   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
 
   /*
   m_ScalarOpacityFunction->Initialize();
   m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
   m_ScalarOpacityFunction->AddPoint(0.0,0.0);
   m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
   m_GradientOpacityFunction->Initialize();
   m_GradientOpacityFunction->AddPoint(m_Min,0.0);
   m_GradientOpacityFunction->AddPoint(0.0,1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
   m_GradientOpacityFunction->AddPoint(m_Max,1.0);
   m_ColorTransferFunction->RemoveAllPoints();
   m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
   m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);
   m_ColorTransferFunction->SetColorSpaceToHSV();
   MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
   */
 }
 
 void TransferFunction::InitializeByMitkImage( const Image * image )
 {
   HistogramGenerator::Pointer histGen= HistogramGenerator::New();
   histGen->SetImage(image);
   histGen->SetSize(256);
   histGen->ComputeHistogram();
   m_Histogram = histGen->GetHistogram();
   m_Min = (int)GetHistogram()->GetBinMin(0,0);
   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
   m_ScalarOpacityFunction->Initialize();
   m_ScalarOpacityFunction->AddPoint(m_Min,0.0);
   m_ScalarOpacityFunction->AddPoint(0.0,0.0);
   m_ScalarOpacityFunction->AddPoint(m_Max,1.0);
   m_GradientOpacityFunction->Initialize();
   m_GradientOpacityFunction->AddPoint(m_Min,0.0);
   m_GradientOpacityFunction->AddPoint(0.0,1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.125),1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.2),1.0);
   m_GradientOpacityFunction->AddPoint((m_Max*0.25),1.0);
   m_GradientOpacityFunction->AddPoint(m_Max,1.0);
   m_ColorTransferFunction->RemoveAllPoints();
   m_ColorTransferFunction->AddRGBPoint(m_Min,1,0,0);
   m_ColorTransferFunction->AddRGBPoint(m_Max,1,1,0);
   m_ColorTransferFunction->SetColorSpaceToHSV();
   //MITK_INFO << "min/max in tf-c'tor:" << m_Min << "/" << m_Max << std::endl;
 }
 
 
 void TransferFunction::InitializeHistogram( const Image * image )
 {
   HistogramGenerator::Pointer histGen= HistogramGenerator::New();
   histGen->SetImage(image);
   histGen->SetSize(256);
   histGen->ComputeHistogram();
   m_Histogram = histGen->GetHistogram();
   m_Min = (int)GetHistogram()->GetBinMin(0,0);
   m_Max = (int)GetHistogram()->GetBinMax(0, GetHistogram()->Size()-1);
 }
 
 void TransferFunction::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent << "ScalarOpacity: ";
   m_ScalarOpacityFunction->PrintHeader(os, vtkIndent());
   os << indent << "GradientOpacity: ";
   m_GradientOpacityFunction->PrintHeader(os, vtkIndent());
   os << indent << "ColorTransfer: ";
   m_ColorTransferFunction->PrintHeader(os, vtkIndent());
   os << indent << "Min: " << m_Min << ", Max: " << m_Max << std::endl;
 }
 
 itk::LightObject::Pointer mitk::TransferFunction::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
 
 }// namespace
diff --git a/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp b/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
index b5215c36d7..13dc0ce75e 100644
--- a/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
+++ b/Core/Code/DataManagement/mitkTransferFunctionProperty.cpp
@@ -1,61 +1,61 @@
 /*===================================================================
 
 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 "mitkTransferFunctionProperty.h"
 
 
 namespace mitk {
 
 bool TransferFunctionProperty::IsEqual(const BaseProperty& property) const
 {
   return *(this->m_Value) == *(static_cast<const Self&>(property).m_Value);
 }
 
 bool TransferFunctionProperty::Assign(const BaseProperty& property)
 {
   this->m_Value = static_cast<const Self&>(property).m_Value;
   return true;
 }
 
 std::string  TransferFunctionProperty::GetValueAsString() const
 {
   std::stringstream myStr;
   myStr << GetValue();
   return myStr.str();
 }
 
 TransferFunctionProperty::TransferFunctionProperty()
-  : BaseProperty()
+    : BaseProperty(), m_Value(mitk::TransferFunction::New())
 {}
 
 TransferFunctionProperty::TransferFunctionProperty(const TransferFunctionProperty& other)
   : BaseProperty(other)
   , m_Value(other.m_Value->Clone())
 {
 }
 
 TransferFunctionProperty::TransferFunctionProperty( mitk::TransferFunction::Pointer value )
   : BaseProperty(), m_Value( value )
 {}
 
 itk::LightObject::Pointer TransferFunctionProperty::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }
 
 } // namespace mitk