diff --git a/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h b/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
index df1180fc96..46af198c5b 100644
--- a/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
+++ b/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
@@ -1,74 +1,75 @@
 /*===================================================================
 
 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 MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED
 #define MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED
 
 // MITK
 #include "MitkMapperExtExports.h"
 #include "mitkBaseRenderer.h"
 #include "mitkCommon.h"
 #include "mitkImage.h"
 #include "mitkVtkMapper.h"
 
 // VTK
 #include <vtkImageChangeInformation.h>
 #include <vtkSmartPointer.h>
 #include <vtkVersionMacros.h>
 #include <vtkVolumeProperty.h>
 #include <vtkSmartVolumeMapper.h>
 #include <vtkImageData.h>
 
 namespace mitk
 {
 
   //##Documentation
   //## @brief Vtk-based mapper for VolumeData
   //##
   //## @ingroup Mapper
   class MITKMAPPEREXT_EXPORT VolumeMapperVtkSmart3D : public VtkMapper
   {
   public:
     mitkClassMacro(VolumeMapperVtkSmart3D, VtkMapper);
 
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
     virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
 
     virtual void ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer) override;
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
     
   protected:
     VolumeMapperVtkSmart3D();
     virtual ~VolumeMapperVtkSmart3D();
 
     virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
     void createMapper(vtkImageData*);
     void createVolume();
     void createVolumeProperty();
     vtkImageData* GetInputImage();
 
     vtkSmartPointer<vtkVolume> m_Volume;
     vtkSmartPointer<vtkSmartVolumeMapper> m_SmartVolumeMapper;
     vtkSmartPointer<vtkVolumeProperty> m_VolumeProperty;
     
     void UpdateTransferFunctions(mitk::BaseRenderer *renderer);
+    void UpdateRenderMode(mitk::BaseRenderer *renderer);
   };
 
 } // namespace mitk
 
 #endif /* MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED */
diff --git a/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
index fdee2a9107..8b254c25d6 100644
--- a/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
+++ b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
@@ -1,167 +1,255 @@
 /*===================================================================
 
 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 "mitkVolumeMapperVtkSmart3D.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkTransferFunctionInitializer.h"
+#include "mitkLevelWindowProperty.h"
 #include <vtkObjectFactory.h>
 #include <vtkRenderingOpenGL2ObjectFactory.h>
 #include <vtkRenderingVolumeOpenGL2ObjectFactory.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 
 void mitk::VolumeMapperVtkSmart3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
+  if (this->GetDataNode()->GetMTime() < this->GetMTime())
+  {
+    return;
+  }
+
   bool value;
   this->GetDataNode()->GetBoolProperty("volumerendering", value, renderer);
   if (!value)
   {
     m_Volume->VisibilityOff();
     return;
   }
   else
   {
     m_Volume->VisibilityOn();
   }
 
   UpdateTransferFunctions(renderer);
+  UpdateRenderMode(renderer);
+  this->Modified();
 }
 
 vtkProp* mitk::VolumeMapperVtkSmart3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   if (!m_Volume->GetMapper())
   {
     createMapper(GetInputImage());
     createVolume();
     createVolumeProperty();
   }
 
   return m_Volume;
 }
 
 void mitk::VolumeMapperVtkSmart3D::ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)
 {
 
 }
 
 void mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
 {
+  // GPU_INFO << "SetDefaultProperties";
+
   node->AddProperty("volumerendering", mitk::BoolProperty::New(false), renderer, overwrite);
+  node->AddProperty("volumerendering.usemip", mitk::BoolProperty::New(false), renderer, overwrite);
+
+  node->AddProperty("volumerendering.cpu.ambient", mitk::FloatProperty::New(0.10f), renderer, overwrite);
+  node->AddProperty("volumerendering.cpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
+  node->AddProperty("volumerendering.cpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
+  node->AddProperty("volumerendering.cpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
+  node->AddProperty("volumerendering.usegpu", mitk::BoolProperty::New(false), renderer, overwrite);
+  node->AddProperty("volumerendering.useray", mitk::BoolProperty::New(false), renderer, overwrite);
+
+  node->AddProperty("volumerendering.gpu.ambient", mitk::FloatProperty::New(0.25f), renderer, overwrite);
+  node->AddProperty("volumerendering.gpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
+  node->AddProperty("volumerendering.gpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
+  node->AddProperty("volumerendering.gpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
+
+  node->AddProperty("binary", mitk::BoolProperty::New(false), renderer, overwrite);
+
+  mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
+  if (image.IsNotNull() && image->IsInitialized())
+  {
+    if ((overwrite) || (node->GetProperty("levelwindow", renderer) == nullptr))
+    {
+      mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
+      mitk::LevelWindow levelwindow;
+      levelwindow.SetAuto(image);
+      levWinProp->SetLevelWindow(levelwindow);
+      node->SetProperty("levelwindow", levWinProp, renderer);
+    }
+
+    if ((overwrite) || (node->GetProperty("TransferFunction", renderer) == nullptr))
+    {
+      // add a default transfer function
+      mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
+      mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
+      tfInit->SetTransferFunctionMode(0);
+      node->SetProperty("TransferFunction", mitk::TransferFunctionProperty::New(tf.GetPointer()));
+    }
+  }
+
+  Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 vtkImageData* mitk::VolumeMapperVtkSmart3D::GetInputImage()
 {
   mitk::Image *input = const_cast<mitk::Image *>(static_cast<const mitk::Image *>(this->GetDataNode()->GetData()));
   vtkImageData* img = input->GetVtkImageData(this->GetTimestep());
   img->SetSpacing(1,1,1);
 
   return img;
 }
 
 void mitk::VolumeMapperVtkSmart3D::createMapper(vtkImageData* imageData)
 {
   m_SmartVolumeMapper->SetBlendModeToComposite();
   m_SmartVolumeMapper->SetInputData(imageData);
 }
 
 void mitk::VolumeMapperVtkSmart3D::createVolume()
 {    
   m_Volume->VisibilityOff();
   m_Volume->SetMapper(m_SmartVolumeMapper);
   m_Volume->SetProperty(m_VolumeProperty);
 }
 
 void mitk::VolumeMapperVtkSmart3D::createVolumeProperty()
 {
-  m_VolumeProperty->ShadeOff();
+  m_VolumeProperty->ShadeOn();
   m_VolumeProperty->SetInterpolationType(VTK_LINEAR_INTERPOLATION);
-
-  vtkSmartPointer<vtkPiecewiseFunction> compositeOpacity =
-    vtkSmartPointer<vtkPiecewiseFunction>::New();
-  compositeOpacity->AddPoint(-1000.0, 0.0);
-  compositeOpacity->AddPoint(100.0, 0.0);
-  compositeOpacity->AddPoint(3000.0, 1.0);
-  m_VolumeProperty->SetScalarOpacity(compositeOpacity); // composite first.
-
-  vtkSmartPointer<vtkColorTransferFunction> color =
-    vtkSmartPointer<vtkColorTransferFunction>::New();
-  color->AddRGBPoint(0.0, 1.0, 1.0, 1.0);
-  color->AddRGBPoint(255.0, 1.0, 1.0, 1.0);
-  m_VolumeProperty->SetColor(color);
 }
 
 void mitk::VolumeMapperVtkSmart3D::UpdateTransferFunctions(mitk::BaseRenderer *renderer)
 {
   vtkSmartPointer<vtkPiecewiseFunction> opacityTransferFunction;
   vtkSmartPointer<vtkPiecewiseFunction> gradientTransferFunction;
   vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction;
 
   bool isBinary = false;
 
   this->GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
 
   if (isBinary)
   {
     colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
-
+    
     float rgb[3];
     if (!GetDataNode()->GetColor(rgb, renderer))
       rgb[0] = rgb[1] = rgb[2] = 1;
     colorTransferFunction->AddRGBPoint(0, rgb[0], rgb[1], rgb[2]);
     colorTransferFunction->Modified();
+
+    opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
+    gradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
   }
   else
   {
     mitk::TransferFunctionProperty *transferFunctionProp =
       dynamic_cast<mitk::TransferFunctionProperty *>(this->GetDataNode()->GetProperty("TransferFunction", renderer));
 
     if (transferFunctionProp)
     {
       opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
       gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
       colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
     }
     else
     {
       opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
       gradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
       colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
     }
   }
 
   m_VolumeProperty->SetColor(colorTransferFunction);
   m_VolumeProperty->SetScalarOpacity(opacityTransferFunction);
   m_VolumeProperty->SetGradientOpacity(gradientTransferFunction);
+}
+
 
+void mitk::VolumeMapperVtkSmart3D::UpdateRenderMode(mitk::BaseRenderer *renderer)
+{
+  bool usegpu = false;
+  bool useray = false;
+  bool usemip = false;
+  this->GetDataNode()->GetBoolProperty("volumerendering.usegpu", usegpu);
+  this->GetDataNode()->GetBoolProperty("volumerendering.useray", useray);
+  this->GetDataNode()->GetBoolProperty("volumerendering.usemip", usemip);
+
+  if (usegpu)
+    m_SmartVolumeMapper->SetRequestedRenderModeToGPU();
+  else if (useray)
+    m_SmartVolumeMapper->SetRequestedRenderModeToRayCast();
+  else
+    m_SmartVolumeMapper->SetRequestedRenderModeToDefault();
+
+  int blendMode;
+  if (this->GetDataNode()->GetIntProperty("volumerendering.blendmode", blendMode))
+    m_SmartVolumeMapper->SetBlendMode(blendMode);
+  else if (usemip)
+    m_SmartVolumeMapper->SetBlendMode(vtkSmartVolumeMapper::MAXIMUM_INTENSITY_BLEND);
+      
+  // shading parameter
+  if (m_SmartVolumeMapper->GetRequestedRenderMode() == vtkSmartVolumeMapper::GPURenderMode)
+  {
+    float value = 0;
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient", value, renderer))
+      m_VolumeProperty->SetAmbient(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse", value, renderer))
+      m_VolumeProperty->SetDiffuse(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular", value, renderer))
+      m_VolumeProperty->SetSpecular(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power", value, renderer))
+      m_VolumeProperty->SetSpecularPower(value);
+  }
+  else
+  {
+    float value = 0;
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient", value, renderer))
+      m_VolumeProperty->SetAmbient(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse", value, renderer))
+      m_VolumeProperty->SetDiffuse(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular", value, renderer))
+      m_VolumeProperty->SetSpecular(value);
+    if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power", value, renderer))
+      m_VolumeProperty->SetSpecularPower(value);
+  }
 }
 
 mitk::VolumeMapperVtkSmart3D::VolumeMapperVtkSmart3D()
 {
   vtkObjectFactory::RegisterFactory(vtkRenderingOpenGL2ObjectFactory::New());
   vtkObjectFactory::RegisterFactory(vtkRenderingVolumeOpenGL2ObjectFactory::New());
 
   m_SmartVolumeMapper = vtkSmartPointer<vtkSmartVolumeMapper>::New();
   m_SmartVolumeMapper->SetBlendModeToComposite();
   m_VolumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
   m_Volume = vtkSmartPointer<vtkVolume>::New();
 }
 
 mitk::VolumeMapperVtkSmart3D::~VolumeMapperVtkSmart3D()
 {
 
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
index 266133681e..8dc1efe285 100755
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.cpp
@@ -1,338 +1,344 @@
 /*===================================================================
 
 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 "QmitkVolumeVisualizationView.h"
 
 #include <QComboBox>
 
 #include <vtkVersionMacros.h>
+#include <vtkSmartVolumeMapper.h>
 
 #include <berryISelectionProvider.h>
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 //#include <berryISelectionService.h>
 #include <mitkDataNodeObject.h>
 
 #include <mitkProperties.h>
 #include <mitkNodePredicateDataType.h>
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkTransferFunctionInitializer.h>
 #include "mitkHistogramGenerator.h"
 #include "QmitkPiecewiseFunctionCanvas.h"
 #include "QmitkColorTransferFunctionCanvas.h"
 
 #include "mitkBaseRenderer.h"
 
 #include "mitkVtkVolumeRenderingProperty.h"
 
 #include <mitkIRenderingManager.h>
 
 #include <QToolTip>
 
 const std::string QmitkVolumeVisualizationView::VIEW_ID =
 "org.mitk.views.volumevisualization";
 
-enum RenderMode
-{
-  RM_CPU_COMPOSITE_RAYCAST = 0,
-  RM_CPU_MIP_RAYCAST       = 1,
-  RM_GPU_COMPOSITE_SLICING = 2,
-  RM_GPU_COMPOSITE_RAYCAST = 3,
-  RM_GPU_MIP_RAYCAST       = 4
-};
+enum {DEFAULT_RENDERMODE = 0, RAYCAST_RENDERMODE = 1, GPU_RENDERMODE = 2};
 
 QmitkVolumeVisualizationView::QmitkVolumeVisualizationView()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkVolumeVisualizationView::~QmitkVolumeVisualizationView()
 {
 }
 
 void QmitkVolumeVisualizationView::CreateQtPartControl(QWidget* parent)
 {
 
   if (!m_Controls)
   {
     m_Controls = new Ui::QmitkVolumeVisualizationViewControls;
     m_Controls->setupUi(parent);
 
     // Fill the tf presets in the generator widget
     std::vector<std::string> names;
     mitk::TransferFunctionInitializer::GetPresetNames(names);
     for (std::vector<std::string>::const_iterator it = names.begin();
          it != names.end(); ++it)
     {
       m_Controls->m_TransferFunctionGeneratorWidget->AddPreset(QString::fromStdString(*it));
     }
-
-    m_Controls->m_RenderMode->addItem("CPU raycast");
-    m_Controls->m_RenderMode->addItem("CPU MIP raycast");
-    m_Controls->m_RenderMode->addItem("GPU slicing");
-    m_Controls->m_RenderMode->addItem("GPU raycast");
-    m_Controls->m_RenderMode->addItem("GPU MIP raycast");
+    
+    // see enum in vtkSmartVolumeMapper
+    m_Controls->m_RenderMode->addItem("Default");
+    m_Controls->m_RenderMode->addItem("RayCast");
+    m_Controls->m_RenderMode->addItem("GPU");
+
+    // see vtkVolumeMapper::BlendModes
+    m_Controls->m_BlendMode->addItem("Comp");
+    m_Controls->m_BlendMode->addItem("Max");
+    m_Controls->m_BlendMode->addItem("Min");
+    m_Controls->m_BlendMode->addItem("Avg");
+    m_Controls->m_BlendMode->addItem("Add");
 
     connect( m_Controls->m_EnableRenderingCB, SIGNAL( toggled(bool) ),this, SLOT( OnEnableRendering(bool) ));
-    connect( m_Controls->m_EnableLOD, SIGNAL( toggled(bool) ),this, SLOT( OnEnableLOD(bool) ));
-    connect( m_Controls->m_RenderMode, SIGNAL( activated(int) ),this, SLOT( OnRenderMode(int) ));
+    connect(m_Controls->m_RenderMode, SIGNAL(activated(int)), this, SLOT(OnRenderMode(int)));
+    connect(m_Controls->m_BlendMode, SIGNAL(activated(int)), this, SLOT(OnBlendMode(int)));
 
     connect( m_Controls->m_TransferFunctionGeneratorWidget, SIGNAL( SignalUpdateCanvas( ) ),   m_Controls->m_TransferFunctionWidget, SLOT( OnUpdateCanvas( ) ) );
     connect( m_Controls->m_TransferFunctionGeneratorWidget, SIGNAL(SignalTransferFunctionModeChanged(int)), SLOT(OnMitkInternalPreset(int)));
 
     m_Controls->m_EnableRenderingCB->setEnabled(false);
-    m_Controls->m_EnableLOD->setEnabled(false);
+    m_Controls->m_BlendMode->setEnabled(false);
     m_Controls->m_RenderMode->setEnabled(false);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
 
     m_Controls->m_SelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
-
   }
 }
 
 void QmitkVolumeVisualizationView::OnMitkInternalPreset( int mode )
 {
   if (m_SelectedNode.IsNull()) return;
 
   mitk::DataNode::Pointer node(m_SelectedNode.GetPointer());
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   if (node->GetProperty(transferFuncProp, "TransferFunction"))
   {
     //first item is only information
     if( --mode == -1 )
       return;
 
     // -- Creat new TransferFunction
     mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(transferFuncProp->GetValue());
     tfInit->SetTransferFunctionMode(mode);
     RequestRenderWindowUpdate();
     m_Controls->m_TransferFunctionWidget->OnUpdateCanvas();
   }
 }
 
 
 void QmitkVolumeVisualizationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   bool weHadAnImageButItsNotThreeDeeOrFourDee = false;
 
   mitk::DataNode::Pointer node;
 
   for (mitk::DataNode::Pointer currentNode: nodes)
   {
     if( currentNode.IsNotNull() && dynamic_cast<mitk::Image*>(currentNode->GetData()) )
     {
       if( dynamic_cast<mitk::Image*>(currentNode->GetData())->GetDimension()>=3 )
       {
         if (node.IsNull())
         {
           node = currentNode;
         }
       }
       else
       {
         weHadAnImageButItsNotThreeDeeOrFourDee = true;
       }
     }
   }
 
   if( node.IsNotNull() )
   {
     m_Controls->m_NoSelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
     m_Controls->m_SelectedImageLabel->show();
 
     std::string  infoText;
 
     if (node->GetName().empty())
       infoText = std::string("Selected Image: [currently selected image has no name]");
     else
       infoText = std::string("Selected Image: ") + node->GetName();
 
     m_Controls->m_SelectedImageLabel->setText( QString( infoText.c_str() ) );
 
     m_SelectedNode = node;
   }
   else
   {
     if(weHadAnImageButItsNotThreeDeeOrFourDee)
     {
       m_Controls->m_NoSelectedImageLabel->hide();
       m_Controls->m_ErrorImageLabel->show();
       std::string  infoText;
       infoText = std::string("only 3D or 4D images are supported");
       m_Controls->m_ErrorImageLabel->setText( QString( infoText.c_str() ) );
     }
     else
     {
       m_Controls->m_SelectedImageLabel->hide();
       m_Controls->m_ErrorImageLabel->hide();
       m_Controls->m_NoSelectedImageLabel->show();
     }
 
     m_SelectedNode = 0;
   }
 
   UpdateInterface();
 }
 
 
 void QmitkVolumeVisualizationView::UpdateInterface()
 {
   if(m_SelectedNode.IsNull())
   {
     // turnoff all
     m_Controls->m_EnableRenderingCB->setChecked(false);
     m_Controls->m_EnableRenderingCB->setEnabled(false);
 
-    m_Controls->m_EnableLOD->setChecked(false);
-    m_Controls->m_EnableLOD->setEnabled(false);
+    m_Controls->m_BlendMode->setCurrentIndex(0);
+    m_Controls->m_BlendMode->setEnabled(false);
 
     m_Controls->m_RenderMode->setCurrentIndex(0);
     m_Controls->m_RenderMode->setEnabled(false);
 
     m_Controls->m_TransferFunctionWidget->SetDataNode(0);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
 
     m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(0);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   bool enabled = false;
 
   m_SelectedNode->GetBoolProperty("volumerendering",enabled);
   m_Controls->m_EnableRenderingCB->setEnabled(true);
   m_Controls->m_EnableRenderingCB->setChecked(enabled);
 
   if(!enabled)
   {
     // turnoff all except volumerendering checkbox
-    m_Controls->m_EnableLOD->setChecked(false);
-    m_Controls->m_EnableLOD->setEnabled(false);
+    m_Controls->m_BlendMode->setCurrentIndex(0);
+    m_Controls->m_BlendMode->setEnabled(false);
 
     m_Controls->m_RenderMode->setCurrentIndex(0);
     m_Controls->m_RenderMode->setEnabled(false);
 
     m_Controls->m_TransferFunctionWidget->SetDataNode(0);
     m_Controls->m_TransferFunctionWidget->setEnabled(false);
 
     m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(0);
     m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(false);
     return;
   }
 
   // otherwise we can activate em all
-  enabled = false;
-  m_SelectedNode->GetBoolProperty("volumerendering.uselod",enabled);
-  m_Controls->m_EnableLOD->setEnabled(true);
-  m_Controls->m_EnableLOD->setChecked(enabled);
-
+  m_Controls->m_BlendMode->setEnabled(true);
   m_Controls->m_RenderMode->setEnabled(true);
 
   // Determine Combo Box mode
   {
     bool usegpu=false;
     bool useray=false;
     bool usemip=false;
     m_SelectedNode->GetBoolProperty("volumerendering.usegpu",usegpu);
     m_SelectedNode->GetBoolProperty("volumerendering.useray",useray);
     m_SelectedNode->GetBoolProperty("volumerendering.usemip",usemip);
+          
+    int blendMode;
+    if (m_SelectedNode->GetIntProperty("volumerendering.blendmode", blendMode))
+      m_Controls->m_BlendMode->setCurrentIndex(blendMode);
 
-    int mode = 0;
+    if (usemip)
+      m_Controls->m_BlendMode->setCurrentIndex(vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND);
 
-    if(useray)
-    {
-      if(usemip)
-        mode=RM_GPU_MIP_RAYCAST;
-      else
-        mode=RM_GPU_COMPOSITE_RAYCAST;
-    }
-    else if(usegpu)
-      mode=RM_GPU_COMPOSITE_SLICING;
-    else
-    {
-      if(usemip)
-        mode=RM_CPU_MIP_RAYCAST;
-      else
-        mode=RM_CPU_COMPOSITE_RAYCAST;
-    }
+    int mode = DEFAULT_RENDERMODE;
 
+    if (useray)
+      mode = RAYCAST_RENDERMODE;
+    else if(usegpu)
+      mode = GPU_RENDERMODE;
+        
     m_Controls->m_RenderMode->setCurrentIndex(mode);
+        
   }
 
   m_Controls->m_TransferFunctionWidget->SetDataNode(m_SelectedNode);
   m_Controls->m_TransferFunctionWidget->setEnabled(true);
   m_Controls->m_TransferFunctionGeneratorWidget->SetDataNode(m_SelectedNode);
   m_Controls->m_TransferFunctionGeneratorWidget->setEnabled(true);
 }
 
 
 void QmitkVolumeVisualizationView::OnEnableRendering(bool state)
 {
   if(m_SelectedNode.IsNull())
     return;
 
   m_SelectedNode->SetProperty("volumerendering",mitk::BoolProperty::New(state));
   UpdateInterface();
   RequestRenderWindowUpdate();
 }
 
-void QmitkVolumeVisualizationView::OnEnableLOD(bool state)
+void QmitkVolumeVisualizationView::OnBlendMode(int mode)
 {
-  if(m_SelectedNode.IsNull())
+  if (m_SelectedNode.IsNull())
     return;
 
-  m_SelectedNode->SetProperty("volumerendering.uselod",mitk::BoolProperty::New(state));
+  bool usemip = false;
+  if (mode == vtkVolumeMapper::MAXIMUM_INTENSITY_BLEND)
+    usemip = true;
+
+  m_SelectedNode->SetProperty("volumerendering.usemip", mitk::BoolProperty::New(usemip));
+  m_SelectedNode->SetProperty("volumerendering.blendmode", mitk::IntProperty::New(mode));
+
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::OnRenderMode(int mode)
 {
   if(m_SelectedNode.IsNull())
     return;
-
-  bool usegpu=mode==RM_GPU_COMPOSITE_SLICING;
-  bool useray=(mode==RM_GPU_COMPOSITE_RAYCAST)||(mode==RM_GPU_MIP_RAYCAST);
-  bool usemip=(mode==RM_GPU_MIP_RAYCAST)||(mode==RM_CPU_MIP_RAYCAST);
+  
+  bool usegpu = false;
+  if (mode == GPU_RENDERMODE)
+    usegpu = true;
+
+  bool useray = false;
+  if (mode == RAYCAST_RENDERMODE)
+    useray = true;
+  
+  if (mode == DEFAULT_RENDERMODE)
+  {
+    useray = true;
+    usegpu = true;
+  }
 
   m_SelectedNode->SetProperty("volumerendering.usegpu",mitk::BoolProperty::New(usegpu));
   m_SelectedNode->SetProperty("volumerendering.useray",mitk::BoolProperty::New(useray));
-  m_SelectedNode->SetProperty("volumerendering.usemip",mitk::BoolProperty::New(usemip));
 
   RequestRenderWindowUpdate();
 }
 
 void QmitkVolumeVisualizationView::SetFocus()
 {
 
 }
 
 void QmitkVolumeVisualizationView::NodeRemoved(const mitk::DataNode* node)
 {
   if(m_SelectedNode == node)
   {
     m_SelectedNode=0;
     m_Controls->m_SelectedImageLabel->hide();
     m_Controls->m_ErrorImageLabel->hide();
     m_Controls->m_NoSelectedImageLabel->show();
     UpdateInterface();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.h b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.h
index 601a8e1009..8bd075f564 100755
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.h
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationView.h
@@ -1,83 +1,82 @@
 /*===================================================================
 
 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 QMITKVOLUMEVISUALIZATIONVIEW_H_
 #define QMITKVOLUMEVISUALIZATIONVIEW_H_
 
 #include <QmitkAbstractView.h>
 
 #include <mitkDataNodeSelection.h>
 
 #include <mitkWeakPointer.h>
 
 #include <mitkImage.h>
 
 #include "mitkDataStorage.h"
 
 #include <QmitkDataStorageListModel.h>
 #include <QmitkDataStorageComboBox.h>
 #include <QmitkTransferFunctionWidget.h>
 
 #include "ui_QmitkVolumeVisualizationViewControls.h"
 
 /**
  * \ingroup org_mitk_gui_qt_volumevisualization_internal
  */
 class QmitkVolumeVisualizationView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   void SetFocus() override;
 
   QmitkVolumeVisualizationView();
 
   virtual ~QmitkVolumeVisualizationView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Invoked when the DataManager selection changed
   ///
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   static const std::string VIEW_ID;
 
 
 protected slots:
 
   void OnMitkInternalPreset( int mode );
 
   void OnEnableRendering( bool state );
-  void OnEnableLOD( bool state );
   void OnRenderMode( int mode );
-
+  void OnBlendMode(int mode);
 
 protected:
 
   Ui::QmitkVolumeVisualizationViewControls* m_Controls;
 
 private:
 
   mitk::WeakPointer<mitk::DataNode> m_SelectedNode;
 
   void UpdateInterface();
   void NodeRemoved(const mitk::DataNode* node) override;
 
 };
 
 #endif /*QMITKVOLUMEVISUALIZATIONVIEW_H_*/
diff --git a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationViewControls.ui b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationViewControls.ui
index 982bc0f0a9..2a0476f821 100644
--- a/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.volumevisualization/src/internal/QmitkVolumeVisualizationViewControls.ui
@@ -1,334 +1,327 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkVolumeVisualizationViewControls</class>
  <widget class="QWidget" name="QmitkVolumeVisualizationViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>324</width>
     <height>679</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QLabel" name="m_ErrorImageLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="palette">
       <palette>
        <active>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </active>
        <inactive>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </inactive>
        <disabled>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
        </disabled>
       </palette>
      </property>
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="m_NoSelectedImageLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="palette">
       <palette>
        <active>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>197</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>189</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </active>
        <inactive>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>197</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>191</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>189</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </inactive>
        <disabled>
         <colorrole role="WindowText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>120</red>
            <green>120</green>
            <blue>120</blue>
           </color>
          </brush>
         </colorrole>
        </disabled>
       </palette>
      </property>
      <property name="text">
       <string>Please select a volume image!</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="m_SelectedImageLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QCheckBox" name="m_EnableRenderingCB">
        <property name="toolTip">
         <string>Click this checkbox to enable volumerendering in the 3D view of the selected image.</string>
        </property>
        <property name="text">
         <string>Volumerendering</string>
        </property>
       </widget>
      </item>
-     <item>
-      <widget class="QCheckBox" name="m_EnableLOD">
-       <property name="toolTip">
-        <string>Level of detail (LOD) enables a fast but lower quality preview rendering to increase interactivity.</string>
-       </property>
-       <property name="text">
-        <string>LOD</string>
-       </property>
-      </widget>
-     </item>
      <item>
       <widget class="QComboBox" name="m_RenderMode">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>1</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Select render mode</string>
        </property>
       </widget>
      </item>
+     <item>
+      <widget class="QComboBox" name="m_BlendMode"/>
+     </item>
     </layout>
    </item>
    <item>
     <widget class="QmitkTransferFunctionGeneratorWidget" name="m_TransferFunctionGeneratorWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QmitkTransferFunctionWidget" name="m_TransferFunctionWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>1</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkTransferFunctionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkTransferFunctionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkTransferFunctionGeneratorWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkTransferFunctionGeneratorWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <includes>
   <include location="local">QmitkDataStorageComboBox.h</include>
  </includes>
  <resources/>
  <connections/>
 </ui>