diff --git a/Modules/DicomRT/mitkDicomRTReader.cpp b/Modules/DicomRT/mitkDicomRTReader.cpp
index bfd38defc2..473001f847 100644
--- a/Modules/DicomRT/mitkDicomRTReader.cpp
+++ b/Modules/DicomRT/mitkDicomRTReader.cpp
@@ -1,542 +1,547 @@
 /*===================================================================
 
 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 "mitkDicomRTReader.h"
 
 #include <vtkColorTransferFunction.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 namespace mitk
 {
 
   DicomRTReader::DicomRTReader(){}
 
   DicomRTReader::~DicomRTReader(){}
 
   DicomRTReader::RoiEntry::RoiEntry()
   {
     Number=0;
     DisplayColor[0]=1.0;
     DisplayColor[1]=0.0;
     DisplayColor[2]=0.0;
     ContourModelSet=mitk::ContourModelSet::New();
   }
 
   DicomRTReader::RoiEntry::~RoiEntry(){}
 
   DicomRTReader::RoiEntry::RoiEntry(const RoiEntry& src)
   {
     Number=src.Number;
     Name=src.Name;
     Description=src.Description;
     DisplayColor[0]=src.DisplayColor[0];
     DisplayColor[1]=src.DisplayColor[1];
     DisplayColor[2]=src.DisplayColor[2];
     ContourModelSet=mitk::ContourModelSet::New();
     SetPolyData(src.ContourModelSet);
   }
 
   DicomRTReader::RoiEntry& DicomRTReader::RoiEntry::operator=(const RoiEntry &src)
   {
     Number=src.Number;
     Name=src.Name;
     Description=src.Description;
     DisplayColor[0]=src.DisplayColor[0];
     DisplayColor[1]=src.DisplayColor[1];
     DisplayColor[2]=src.DisplayColor[2];
     SetPolyData(src.ContourModelSet);
     return (*this);
   }
 
   void DicomRTReader::RoiEntry::SetPolyData(mitk::ContourModelSet::Pointer roiPolyData)
   {
     if (roiPolyData == this->ContourModelSet)
       return;
     this->ContourModelSet = roiPolyData;
   }
 
   std::deque<mitk::ContourModelSet::Pointer> DicomRTReader::ReadDicomFile(char* filename)
   {
     DcmFileFormat file;
     OFCondition outp;
     outp = file.loadFile(filename, EXS_Unknown);
     if(outp.good())
     {
       DcmDataset *dataset = file.getDataset();
       OFString sopClass;
       if(dataset->findAndGetOFString(DCM_SOPClassUID, sopClass).good() && !sopClass.empty())
       {
         if(sopClass == UID_RTDoseStorage)
         {
           mitk::DataNode::Pointer x = mitk::DataNode::New();
           x = this->DicomRTReader::LoadRTDose(dataset, filename);
           ContourModelSetVector y;
           return y;
         }
         else if(sopClass == UID_RTStructureSetStorage)
         {
           ContourModelSetVector x = this->DicomRTReader::ReadStructureSet(dataset);
           return x;
         }
         else if(sopClass == UID_RTPlanStorage)
         {
 //          Function isnt implemented yet
 //          int x = this->DicomRTReader::LoadRTPlan(dataset);
           ContourModelSetVector y;
           return y;
         }
         else
         {
           MITK_ERROR << "Error matching the SOP Class, maybe an unsupported type" << endl;
           ContourModelSetVector y;
           return y;
         }
       }
       else
       {
         MITK_ERROR << "Error reading the SOPClassID" << endl;
         ContourModelSetVector y;
         return y;
       }
     }
     else
     {
       MITK_ERROR << "Error rading the input file" << endl;
       ContourModelSetVector y;
       return y;
     }
   }
 
   size_t DicomRTReader::GetNumberOfRois()
   {
     return this->RoiSequenceVector.size();
   }
 
   DicomRTReader::RoiEntry* DicomRTReader::FindRoiByNumber(unsigned int roiNumber)
   {
     for(unsigned int i=0; i<this->RoiSequenceVector.size(); ++i)
     {
       if(this->RoiSequenceVector[i].Number == roiNumber)
         return &this->RoiSequenceVector[i];
     }
     return NULL;
   }
 
   std::deque<mitk::ContourModelSet::Pointer> DicomRTReader::ReadStructureSet(DcmDataset* dataset)
   {
     /**
      * @brief For storing contourmodelsets that belongs to the same object
      *
      * e.g. An eye consists of several contourmodels (contourmodel consists of several 3D-Points)
      * and together they are a contourmodelset
      */
     ContourModelSetVector contourModelSetVector;
 
     DRTStructureSetIOD structureSetObject;
     OFCondition outp = structureSetObject.read(*dataset);
     if(!outp.good())
     {
       MITK_ERROR << "Error reading the file" << endl;
       std::deque<mitk::ContourModelSet::Pointer> x;
       return x;
     }
     DRTStructureSetROISequence &roiSequence = structureSetObject.getStructureSetROISequence();
     if(!roiSequence.gotoFirstItem().good())
     {
       MITK_ERROR << "Error reading the structure sequence" << endl;
       std::deque<mitk::ContourModelSet::Pointer> x;
       return x;
     }
     do{
       DRTStructureSetROISequence::Item &currentSequence = roiSequence.getCurrentItem();
       if(!currentSequence.isValid())
       {
         continue;
       }
       OFString roiName;
       OFString roiDescription;
       Sint32 roiNumber;
       RoiEntry roi;
 
       currentSequence.getROIName(roiName);
       currentSequence.getROIDescription(roiDescription);
       currentSequence.getROINumber(roiNumber);
 
       roi.Name = roiName.c_str();
       roi.Description = roiDescription.c_str();
       roi.Number = roiNumber;
 
       this->RoiSequenceVector.push_back(roi);
     }
     while(roiSequence.gotoNextItem().good());
 
 //    Dont know anymore >.<
 //    OFString refSOPInstUID = GetReferencedFrameOfReferenceSOPInstanceUID(structureSetObject);
 //    double sliceThickness = 2.0;
 
     Sint32 refRoiNumber;
     DRTROIContourSequence &roiContourSeqObject = structureSetObject.getROIContourSequence();
     if(!roiContourSeqObject.gotoFirstItem().good())
     {
       MITK_ERROR << "Error reading the contour sequence" << endl;
       std::deque<mitk::ContourModelSet::Pointer> x;
       return x;
     }
     do
     {
       mitk::ContourModelSet::Pointer contourSet = mitk::ContourModelSet::New();
       DRTROIContourSequence::Item &currentRoiObject = roiContourSeqObject.getCurrentItem();
       if(!currentRoiObject.isValid())
       {
         continue;
       }
       currentRoiObject.getReferencedROINumber(refRoiNumber);
       DRTContourSequence &contourSeqObject = currentRoiObject.getContourSequence();
 
       if(contourSeqObject.gotoFirstItem().good())
       {
         do
         {
           DRTContourSequence::Item &contourItem = contourSeqObject.getCurrentItem();
           if(!contourItem.isValid())
           {
             continue;
           }
           int number;
           OFString contourNumber;
           OFString numberOfPoints;
           OFVector<Float64> contourData_LPS;
           mitk::ContourModel::Pointer contourSequence = mitk::ContourModel::New();
 
           contourItem.getContourNumber(contourNumber);
           contourItem.getNumberOfContourPoints(numberOfPoints);
           contourItem.getContourData(contourData_LPS);
 
           std::stringstream stream;
           stream << numberOfPoints;
           stream >> number;
 
           for(unsigned int i=0; i<contourData_LPS.size()/3;i++)
           {
             mitk::Point3D point;
             point[0] = contourData_LPS.at(3*i);
             point[1] = contourData_LPS.at(3*i+1);
             point[2] = contourData_LPS.at(3*i+2);
             contourSequence->AddVertex(point);
           }
           contourSequence->Close();
           contourSet->AddContourModel(contourSequence);
         }
         while(contourSeqObject.gotoNextItem().good());
       }
       else
       {
         MITK_ERROR << "Error reading contourSeqObject" << endl;
       }
       RoiEntry* refROI = this->FindRoiByNumber(refRoiNumber);
       if(refROI==NULL)
       {
         MITK_ERROR << "Can not find references ROI" << endl;
         continue;
       }
       Sint32 roiColor;
       for(int j=0;j<3;j++)
       {
         currentRoiObject.getROIDisplayColor(roiColor, j);
         refROI->DisplayColor[j] = roiColor/255.0;
       }
       //TODO check for ordering maybe outsource contourmodelsetvector to
       //Roientry and maybe it can replace the ContoruModelSet
       refROI->ContourModelSet = contourSet;
       contourSet->SetProperty("name", mitk::StringProperty::New(refROI->Name));
       contourModelSetVector.push_back(contourSet);
 
     }
     while(roiContourSeqObject.gotoNextItem().good());
 
     MITK_INFO << "Number of ROIs found: " << contourModelSetVector.size() << endl;
 
     return contourModelSetVector;
   }
 
   OFString DicomRTReader::GetReferencedFrameOfReferenceSOPInstanceUID(DRTStructureSetIOD &structSetObject)
   {
     OFString invalid;
     DRTReferencedFrameOfReferenceSequence &refFrameOfRefSeqObject = structSetObject.getReferencedFrameOfReferenceSequence();
     if(!refFrameOfRefSeqObject.gotoFirstItem().good())
       return invalid;
     DRTReferencedFrameOfReferenceSequence::Item &currentRefFrameOfRefSeqItem = refFrameOfRefSeqObject.getCurrentItem();
     if(!currentRefFrameOfRefSeqItem.isValid())
       return invalid;
     DRTRTReferencedStudySequence &refStudySeqObject = currentRefFrameOfRefSeqItem.getRTReferencedStudySequence();
     if(!refStudySeqObject.gotoFirstItem().good())
       return invalid;
     DRTRTReferencedStudySequence::Item &refStudySeqItem = refStudySeqObject.getCurrentItem();
     if(!refStudySeqItem.isValid())
       return invalid;
     DRTRTReferencedSeriesSequence &refSeriesSeqObject = refStudySeqItem.getRTReferencedSeriesSequence();
     if(!refSeriesSeqObject.gotoFirstItem().good())
       return invalid;
     DRTRTReferencedSeriesSequence::Item &refSeriesSeqItem = refSeriesSeqObject.getCurrentItem();
     if(!refSeriesSeqItem.isValid())
       return invalid;
     DRTContourImageSequence &contourImageSeqObject = refSeriesSeqItem.getContourImageSequence();
     if(!contourImageSeqObject.gotoFirstItem().good())
       return invalid;
     DRTContourImageSequence::Item &contourImageSeqItem = contourImageSeqObject.getCurrentItem();
     if(!contourImageSeqItem.isValid())
       return invalid;
 
     OFString resultUid;
     contourImageSeqItem.getReferencedSOPInstanceUID(resultUid);
 
     return resultUid;
   }
 
   int DicomRTReader::LoadRTPlan(DcmDataset *dataset)
   {
     DRTPlanIOD planObject;
     OFCondition result = planObject.read(*dataset);
     if(result.good())
     {
       OFString tmpString, dummyString;
       DRTBeamSequence &planeBeamSeqObject = planObject.getBeamSequence();
       if(planeBeamSeqObject.gotoFirstItem().good())
       {
         do
         {
           DRTBeamSequence::Item &currentBeamSeqItem = planeBeamSeqObject.getCurrentItem();
           if(!currentBeamSeqItem.isValid())
          {
             std::cout << "Invalid Beam Sequence \n\n";
             continue;
           }
           BeamEntry beamEntry;
           OFString beamName, beamDescription, beamType;
           Sint32 beamNumber;
           Float64 srcAxisDistance;
 
           currentBeamSeqItem.getBeamName(beamName);
           currentBeamSeqItem.getBeamDescription(beamDescription);
           currentBeamSeqItem.getBeamType(beamType);
           currentBeamSeqItem.getBeamNumber(beamNumber);
           currentBeamSeqItem.getSourceAxisDistance(srcAxisDistance);
 
           beamEntry.Name = beamName.c_str();
           beamEntry.Description = beamDescription.c_str();
           beamEntry.Type = beamType.c_str();
           beamEntry.Number = beamNumber;
           beamEntry.SrcAxisDistance = srcAxisDistance;
 
           DRTControlPointSequence &controlPointSeqObject = currentBeamSeqItem.getControlPointSequence();
           if(controlPointSeqObject.gotoFirstItem().good())
           {
             DRTControlPointSequence::Item &controlPointItem = controlPointSeqObject.getCurrentItem();
             if(controlPointItem.isValid())
             {
               OFVector<Float64> isocenterPosData_LPS;
               Float64 gantryAngle, patientSupportAngle, beamLimitingDeviceAngle;
               unsigned int numOfCollimatorPosItems = 0;
 
               controlPointItem.getIsocenterPosition(isocenterPosData_LPS);
               controlPointItem.getGantryAngle(gantryAngle);
               controlPointItem.getPatientSupportAngle(patientSupportAngle);
               controlPointItem.getBeamLimitingDeviceAngle(beamLimitingDeviceAngle);
 
               beamEntry.GantryAngle = gantryAngle;
               beamEntry.PatientSupportAngle = patientSupportAngle;
               beamEntry.BeamLimitingDeviceAngle = beamLimitingDeviceAngle;
 
               DRTBeamLimitingDevicePositionSequence &currentCollimatorPosSeqObject = controlPointItem.getBeamLimitingDevicePositionSequence();
               if(currentCollimatorPosSeqObject.gotoFirstItem().good())
               {
                 do
                 {
                   if(++numOfCollimatorPosItems > 2)
                   {
                     std::cout << "Number of collimator position items is higher than 2 but should be exactly 2 ...";
                     return 0;
                   }
                   DRTBeamLimitingDevicePositionSequence::Item &collimatorPositionItem = currentCollimatorPosSeqObject.getCurrentItem();
                   if(collimatorPositionItem.isValid())
                   {
                     OFString beamLimitingDeviceType;
                     OFVector<Float64> leafJawPositions;
 
                     collimatorPositionItem.getRTBeamLimitingDeviceType(beamLimitingDeviceType);
                     collimatorPositionItem.getLeafJawPositions(leafJawPositions);
 
                     if(!beamLimitingDeviceType.compare("ASYMX") || !beamLimitingDeviceType.compare("X"))
                     {
                       beamEntry.LeafJawPositions[0][0] = leafJawPositions[0];
                       beamEntry.LeafJawPositions[0][1] = leafJawPositions[1];
                     }
                     else if(!beamLimitingDeviceType.compare("ASYMY") || !beamLimitingDeviceType.compare("Y"))
                     {
                       beamEntry.LeafJawPositions[1][0] = leafJawPositions[0];
                       beamEntry.LeafJawPositions[1][1] = leafJawPositions[0];
                     }
                     else
                     {
                       std::cout << "Unknown collimator type: " << beamLimitingDeviceType << "\n\n";
                     }
                   }
                 }
                 while(currentCollimatorPosSeqObject.gotoNextItem().good());
               }
             }//endif controlPointItem.isValid()
           }
           this->BeamSequenceVector.push_back(beamEntry);
         }
         while(planeBeamSeqObject.gotoNextItem().good());
       }
     }
     return 1;
   }
 
   mitk::DataNode::Pointer DicomRTReader::LoadRTDose(DcmDataset* dataset, char* filename)
   {
     std::string name = filename;
     itk::FilenamesContainer file;
     file.push_back(name);
 
     mitk::DicomSeriesReader* reader = new mitk::DicomSeriesReader;
 
     mitk::DataNode::Pointer originalNode = reader->LoadDicomSeries(file,false);
     mitk::Image::Pointer originalImage = dynamic_cast<mitk::Image*>(originalNode->GetData());
 
     mitk::Geometry3D::Pointer geo = originalImage->GetGeometry()->Clone();
 
     DRTDoseIOD doseObject;
 
     OFCondition result = doseObject.read(*dataset);
     if(result.bad())
     {
       std::cout << "Error reading the RT Dose dataset\n\n";
       return 0;
     }
 
     Uint16 rows, columns, frames, planarConfig, samplesPP;
     OFString nrframes, doseUnits, doseType, summationType, gridScaling, photoInterpret, lutShape;
     Uint16 &rows_ref = rows;
     Uint16 &columns_ref = columns;
     Float32 gridscale;
+//    const Uint16 *pixelData = NULL;
     const Uint16 *pixelData = NULL;
     unsigned long count = 0;
 
     doseObject.getRows(rows_ref);
     doseObject.getColumns(columns_ref);
     doseObject.getNumberOfFrames(nrframes);
     doseObject.getDoseUnits(doseUnits);
     doseObject.getDoseType(doseType);
     doseObject.getDoseSummationType(summationType);
     doseObject.getDoseGridScaling(gridScaling);
     doseObject.getPhotometricInterpretation(photoInterpret);
     doseObject.getPlanarConfiguration(planarConfig);
     doseObject.getSamplesPerPixel(samplesPP);
     doseObject.getPresentationLUTShape(lutShape);
 
     //standard testing picture: 0.001
     gridscale = OFStandard::atof(gridScaling.c_str());
     std::cout << std::setprecision(10) << "GRIDSCALE >> " << gridscale << endl;
     frames = atoi(nrframes.c_str());
 
+    //dataset->findAndGetUint16Array(DCM_PixelData, pixelData, &count);
     dataset->findAndGetUint16Array(DCM_PixelData, pixelData, &count);
 
     mitk::Image::Pointer image = mitk::Image::New();
     mitk::PixelType pt = mitk::MakeScalarPixelType<float>();
     unsigned int dim[] = {columns,rows,frames};
 
     image->Initialize( pt, 3, dim);
     image->SetSpacing(1.0);
     mitk::Point3D m_origin;
     m_origin[0] = 0.0;
     m_origin[1] = 0.0;
     m_origin[2] = 0.0;
     image->SetOrigin(m_origin);
 
     float* pixel = (float*)image->GetData();
     int size = dim[0]*dim[1]*dim[2];
 
     for(int i=0; i<size; ++i, ++pixel)
     {
+//      MITK_INFO << "PixelData" << i << " : " << pixelData[i] << endl;
       *pixel=pixelData[i] * gridscale;
     }
 
     image->SetGeometry(geo);
 
     double prescripeDose = this->GetMaxDoseValue(dataset);
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetName("DicomRT Dosis");
 //    node->SetProperty("shader.mitkIsoLineShader.Gridscale", mitk::FloatProperty::New(10.0));
     node->SetFloatProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),prescripeDose);
     node->SetBoolProperty(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(),true);
     node->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), 40);
 //    node->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
 //    node->SetProperty("Image Rendering.Mode", renderingMode);
 //    node->SetProperty("opacity", mitk::FloatProperty::New(0.3));
     node->SetData(image);
 
     MITK_INFO << "PRESCRIPEDOSE >> " << prescripeDose << endl;
 
     return node;
   }
 
   double DicomRTReader::GetMaxDoseValue(DcmDataset* dataSet)
   {
     DRTDoseIOD doseObject;
     OFCondition result = doseObject.read(*dataSet);
     if(result.bad())
     {
       std::cout << "Error reading the RT Dose dataset\n\n";
       return 0;
     }
 
     Uint16 rows, columns, frames;
     OFString nrframes, gridScaling;
     const Uint16 *pixelData = NULL;
     Float32 gridscale;
 
     Uint16 &rows_ref = rows;
     Uint16 &columns_ref = columns;
 
     doseObject.getRows(rows_ref);
     doseObject.getColumns(columns_ref);
     doseObject.getNumberOfFrames(nrframes);
     doseObject.getDoseGridScaling(gridScaling);
 
     frames = atoi(nrframes.c_str());
     gridscale = OFStandard::atof(gridScaling.c_str());
+    MITK_INFO << "Gridscale " << gridscale << endl;
+    MITK_INFO << "As String: " << gridScaling << endl;
     dataSet->findAndGetUint16Array(DCM_PixelData, pixelData, 0);
 
     int size = columns*rows*frames;
     double highest = 0;
 
     for(int i=0; i<size; ++i)
     {
       if((pixelData[i]*gridscale)>highest)
       {
         highest = pixelData[i] * gridscale;
       }
     }
 
     return highest;
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
index e032c19adc..2d25beabab 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.cpp
@@ -1,775 +1,789 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Qt
 #include <QMessageBox>
 #include <QMenu>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 
 #include <service/event/ctkEventAdmin.h>
 #include <service/event/ctkEventConstants.h>
 
 // Qmitk
 #include "RTDoseVisualizer.h"
 
 #include <DataStructures/mitkRTConstants.h>
 #include <DataStructures/mitkIsoDoseLevelSetProperty.h>
 #include <DataStructures/mitkIsoDoseLevelVectorProperty.h>
 #include <mitkIsoLevelsGenerator.h>
 #include <mitkRTUIConstants.h>
 
 #include <QmitkDoseColorDelegate.h>
 #include <QmitkDoseValueDelegate.h>
 #include <QmitkDoseVisualStyleDelegate.h>
 #include <QmitkIsoDoseLevelSetModel.h>
 #include <QmitkFreeIsoDoseLevelWidget.h>
 
 #include "org_mitk_gui_qt_rt_dosevisualization_Activator.h"
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <vtkMath.h>
 
 #include <vtkMarchingSquares.h>
 #include <mitkSurface.h>
 #include "QmitkRenderWindow.h"
 #include <mitkExtractSliceFilter.h>
 
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkPolyDataGLMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 
+#include "mitkSliceNavigationController.h"
+
 const std::string RTDoseVisualizer::VIEW_ID = "org.mitk.views.rt.dosevisualization";
 
 RTDoseVisualizer::RTDoseVisualizer()
 {
     m_freeIsoValues = mitk::IsoDoseLevelVector::New();
     m_selectedNodeIsoSet = mitk::IsoDoseLevelSet::New();
 
     m_freeIsoFilter = vtkSmartPointer<vtkContourFilter>::New();
 
     m_selectedNode = NULL;
     m_selectedPresetName = "";
     m_internalUpdate = false;
     m_PrescribedDose_Data = 0.0;
 
+
+    itk::MemberCommand<RTDoseVisualizer>::Pointer sliceChangedCommand =
+        itk::MemberCommand<RTDoseVisualizer>::New();
+    sliceChangedCommand->SetCallbackFunction(this, &RTDoseVisualizer::OnSliceChanged);
+    mitk::SliceNavigationController::Pointer slicer = mitk::SliceNavigationController::New();
+    slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(NULL,0), sliceChangedCommand);
+
 //    mitk::CoreServicePointer<mitk::IShaderRepository> shadoRepo(mitk::CoreServices::GetShaderRepository());
 //    std::string path = "/home/riecker/mitkShaderLighting.xml";
 //    std::string isoShaderName = "mitkIsoLineShader";
 //    MITK_INFO << "shader found under: " << path;
 //    std::ifstream str(path.c_str());
 //    shadoRepo->LoadShader(str,isoShaderName);
 }
 
 RTDoseVisualizer::~RTDoseVisualizer()
 {
   delete m_LevelSetModel;
   delete m_DoseColorDelegate;
   delete m_DoseValueDelegate;
   delete m_DoseVisualDelegate;
 }
 
 void RTDoseVisualizer::SetFocus()
 {
 }
 
+void RTDoseVisualizer::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
+{
+  this->UpdateStdIsolines();
+}
+
 void RTDoseVisualizer::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   m_LevelSetModel = new QmitkIsoDoseLevelSetModel(this);
   m_LevelSetModel->setVisibilityEditOnly(true);
   m_DoseColorDelegate = new QmitkDoseColorDelegate(this);
   m_DoseValueDelegate = new QmitkDoseValueDelegate(this);
   m_DoseVisualDelegate = new QmitkDoseVisualStyleDelegate(this);
 
   this->UpdateByPreferences();
   this->ActualizeIsoLevelsForAllDoseDataNodes();
   this->ActualizeReferenceDoseForAllDoseDataNodes();
   this->ActualizeDisplayStyleForAllDoseDataNodes();
 
   this->m_Controls.isoLevelSetView->setModel(m_LevelSetModel);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(0,m_DoseColorDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(1,m_DoseValueDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(2,m_DoseVisualDelegate);
   this->m_Controls.isoLevelSetView->setItemDelegateForColumn(3,m_DoseVisualDelegate);
   this->m_Controls.isoLevelSetView->setContextMenuPolicy(Qt::CustomContextMenu);
 
   this->m_Controls.btnRemoveFreeValue->setDisabled(true);
 
   connect(m_Controls.btnConvert, SIGNAL(clicked()), this, SLOT(OnConvertButtonClicked()));
   connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), this, SLOT(OnReferenceDoseChanged(double)));
   connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), m_LevelSetModel, SLOT(setReferenceDose(double)));
   connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), m_LevelSetModel, SLOT(setShowAbsoluteDose(bool)));
   connect(m_Controls.radioAbsDose, SIGNAL(toggled(bool)), this, SLOT(OnAbsDoseToggled(bool)));
   connect(m_Controls.btnAddFreeValue, SIGNAL(clicked()), this, SLOT(OnAddFreeValueClicked()));
   connect(m_Controls.btnRemoveFreeValue, SIGNAL(clicked()), this, SLOT(OnRemoveFreeValueClicked()));
   connect(m_Controls.checkGlobalVisColorWash, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisColorWashToggled(bool)));
   connect(m_Controls.checkGlobalVisIsoLine, SIGNAL(toggled(bool)), this, SLOT(OnGlobalVisIsoLineToggled(bool)));
   connect(m_Controls.isoLevelSetView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnShowContextMenuIsoSet(const QPoint&)));
   connect(m_Controls.comboPresets, SIGNAL(currentIndexChanged ( const QString&)), this, SLOT(OnCurrentPresetChanged(const QString&)));
   connect(m_Controls.btnUsePrescribedDose, SIGNAL(clicked()), this, SLOT(OnUsePrescribedDoseClicked()));
 
   ctkServiceReference ref = mitk::org_mitk_gui_qt_rt_dosevisualization_Activator::GetContext()->getServiceReference<ctkEventAdmin>();
 
   ctkDictionary propsForSlot;
   if (ref)
   {
     ctkEventAdmin* eventAdmin = mitk::org_mitk_gui_qt_rt_dosevisualization_Activator::GetContext()->getService<ctkEventAdmin>(ref);
 
     propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::rt::CTKEventConstants::TOPIC_ISO_DOSE_LEVEL_PRESETS_CHANGED.c_str();
     eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventPresetsChanged(ctkEvent)), propsForSlot);
 
     propsForSlot[ctkEventConstants::EVENT_TOPIC] = mitk::rt::CTKEventConstants::TOPIC_REFERENCE_DOSE_CHANGED.c_str();
     eventAdmin->subscribeSlot(this, SLOT(OnHandleCTKEventReferenceDoseChanged(ctkEvent)), propsForSlot);
   }
 
   this->UpdateBySelectedNode();
 }
 
 void RTDoseVisualizer::OnReferenceDoseChanged(double value)
 {
   if (!  m_internalUpdate)
   {
     mitk::DoseValueAbs referenceDose = 0.0;
     bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
 
     if (globalSync)
     {
       mitk::rt::SetReferenceDoseValue(globalSync, value);
       this->ActualizeReferenceDoseForAllDoseDataNodes();
     }
     else
     {
       if (this->m_selectedNode.IsNotNull())
       {
         this->m_selectedNode->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
       }
     }
     if (this->m_selectedNode.IsNotNull())
     {
       mitk::TransferFunction::ControlPoints scalarOpacityPoints;
       scalarOpacityPoints.push_back( std::make_pair(0, 1 ) );
       vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
       mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
       for(mitk::IsoDoseLevelSet::ConstIterator setIT = isoDoseLevelSet->Begin(); setIT != isoDoseLevelSet->End(); ++setIT)
       {
         float *hsv = new float[3];
         vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
         if(setIT->GetVisibleColorWash()){
           cCalc->RGBToHSV(setIT->GetColor()[0],setIT->GetColor()[1],setIT->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
           transferFunction->AddHSVPoint(setIT->GetDoseValue()*value,hsv[0],hsv[1],hsv[2],1.0,1.0);
         }
         else
         {
           scalarOpacityPoints.push_back( std::make_pair(setIT->GetDoseValue()*value, 1 ) );
         }
       }
       mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
       mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
       mitkTransFunc->SetColorTransferFunction(transferFunction);
       mitkTransFunc->SetScalarOpacityPoints(scalarOpacityPoints);
       mitkTransFuncProp->SetValue(mitkTransFunc);
 
       mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
       renderingMode->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
       m_selectedNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
       m_selectedNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
       mitk::TimeSlicedGeometry::Pointer geo3 = this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll());
       mitk::RenderingManager::GetInstance()->InitializeViews( geo3 );
     }
   }
 }
 
 void RTDoseVisualizer::OnAddFreeValueClicked()
 {
   QColor newColor;
   //Use HSV schema of QColor to calculate a different color depending on the
   //number of already existing free iso lines.
   newColor.setHsv((m_freeIsoValues->Size()*85)%360,255,255);
 
   mitk::DataNode::Pointer isoNode = this->UpdatePolyData(1,m_Controls.spinReferenceDose->value()*0.5,m_Controls.spinReferenceDose->value()*0.5);
   m_FreeIsoLines.push_back(isoNode);
 
   mitk::IsoDoseLevel::ColorType color;
   color[0] = newColor.redF();
   color[1] = newColor.greenF();
   color[2] = newColor.blueF();
   m_freeIsoValues->push_back(mitk::IsoDoseLevel::New(0.5,color,true,false));
   UpdateFreeIsoValues();
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   if(m_FreeIsoLines.size()>=3)
     this->m_Controls.btnAddFreeValue->setDisabled(true);
   this->m_Controls.btnRemoveFreeValue->setEnabled(true);
 }
 
 void RTDoseVisualizer::OnRemoveFreeValueClicked()
 {
   m_freeIsoValues->pop_back();
   mitk::DataNode::Pointer isoNode = m_FreeIsoLines.at(m_FreeIsoLines.size()-1);
   m_FreeIsoLines.pop_back();
   m_Filters.pop_back();
   if(m_FreeIsoLines.empty())
     this->m_Controls.btnRemoveFreeValue->setDisabled(true);
   if(m_FreeIsoLines.size()<3)
     this->m_Controls.btnAddFreeValue->setEnabled(true);
   this->GetDataStorage()->Remove(isoNode);
   UpdateFreeIsoValues();
 }
 
 void RTDoseVisualizer::OnUsePrescribedDoseClicked()
 {
   m_Controls.spinReferenceDose->setValue(this->m_PrescribedDose_Data);
 };
 
 
 void RTDoseVisualizer::OnShowContextMenuIsoSet(const QPoint& pos)
 {
   QPoint globalPos = m_Controls.isoLevelSetView->viewport()->mapToGlobal(pos);
 
   QMenu viewMenu;
   QAction* invertIsoLineAct = viewMenu.addAction("Invert iso line visibility");
   QAction* activateIsoLineAct = viewMenu.addAction("Activate all iso lines");
   QAction* deactivateIsoLineAct = viewMenu.addAction("Deactivate all iso lines");
   viewMenu.addSeparator();
   QAction* invertColorWashAct = viewMenu.addAction("Invert color wash visibility");
   QAction* activateColorWashAct = viewMenu.addAction("Activate all color wash levels");
   QAction* deactivateColorWashAct = viewMenu.addAction("Deactivate all color wash levels");
   viewMenu.addSeparator();
   QAction* swapAct = viewMenu.addAction("Swap iso line/color wash visibility");
   // ...
 
   QAction* selectedItem = viewMenu.exec(globalPos);
   if (selectedItem == invertIsoLineAct)
   {
     this->m_LevelSetModel->invertVisibilityIsoLines();
   }
   else if (selectedItem == activateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(true);
   }
   else if (selectedItem == deactivateIsoLineAct)
   {
     this->m_LevelSetModel->switchVisibilityIsoLines(false);
   }
   else if (selectedItem == invertColorWashAct)
   {
     this->m_LevelSetModel->invertVisibilityColorWash();
   }
   else if (selectedItem == activateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(true);
   }
   else if (selectedItem == deactivateColorWashAct)
   {
     this->m_LevelSetModel->switchVisibilityColorWash(false);
   }
   else if (selectedItem == swapAct)
   {
     this->m_LevelSetModel->swapVisibility();
   }
 }
 
 void RTDoseVisualizer::UpdateFreeIsoValues()
 {
   this->m_Controls.listFreeValues->clear();
 
   for (mitk::IsoDoseLevelVector::Iterator pos = this->m_freeIsoValues->Begin(); pos != this->m_freeIsoValues->End(); ++pos)
   {
     QListWidgetItem* item = new QListWidgetItem;
     item->setSizeHint(QSize(0,25));
     QmitkFreeIsoDoseLevelWidget* widget = new QmitkFreeIsoDoseLevelWidget;
 
     float pref;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
 
     widget->setIsoDoseLevel(pos->Value().GetPointer());
     widget->setReferenceDose(pref);
     connect(m_Controls.spinReferenceDose, SIGNAL(valueChanged(double)), widget, SLOT(setReferenceDose(double)));
     connect(widget,SIGNAL(ValueChanged(mitk::IsoDoseLevel*,mitk::DoseValueRel)), this, SLOT(UpdateFreeIsoLine(mitk::IsoDoseLevel*,mitk::DoseValueRel)));
 
     this->m_Controls.listFreeValues->addItem(item);
     this->m_Controls.listFreeValues->setItemWidget(item,widget);
   }
 }
 
 void RTDoseVisualizer::UpdateFreeIsoLine(mitk::IsoDoseLevel * level, mitk::DoseValueRel old)
 {
   float pref;
   m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer slicedImage = this->GetExtractedSlice(image);
 
   m_Filters.at(0)->SetInput(slicedImage->GetVtkImageData());
   m_Filters.at(0)->GenerateValues(1,level->GetDoseValue()*pref,level->GetDoseValue()*pref);
   m_Filters.at(0)->Update();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void RTDoseVisualizer::OnAbsDoseToggled(bool showAbs)
 {
   if (!  m_internalUpdate)
   {
     mitk::rt::SetDoseDisplayAbsolute(showAbs);
     this->ActualizeDisplayStyleForAllDoseDataNodes();
   }
 }
 
 void RTDoseVisualizer::OnGlobalVisColorWashToggled(bool showColorWash)
 {
   if (m_selectedNode.IsNotNull())
   {
     m_selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), showColorWash);
   }
 }
 
 void RTDoseVisualizer::OnGlobalVisIsoLineToggled(bool showIsoLines)
 {
   if (m_selectedNode.IsNotNull())
   {
     m_selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), showIsoLines);
     mitk::NodePredicateProperty::Pointer isoProp = mitk::NodePredicateProperty::
         New(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
     mitk::DataStorage::SetOfObjects::ConstPointer isoSet =  this->GetDataStorage()->GetSubset(isoProp);
     for(mitk::DataStorage::SetOfObjects::ConstIterator iso = isoSet->Begin(); iso!=isoSet->End(); ++iso)
     {
       mitk::DataNode::Pointer node = iso.Value();
       node->SetVisibility(showIsoLines);
     }
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 
 void RTDoseVisualizer::OnConvertButtonClicked()
 {
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
   mitk::DataNode* selectedNode = NULL;
 
   if (!dataNodes.empty())
   {
     selectedNode = dataNodes[0];
   }
 
   if(selectedNode)
   {
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), true);
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(), true);
     selectedNode->SetBoolProperty(mitk::rt::Constants::DOSE_SHOW_ISOLINES_PROPERTY_NAME.c_str(), true);
     selectedNode->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), m_Controls.spinReferenceDose->value());
 
     //selectedNode->GetData()->SetProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::DoubleProperty::New(1.0));
 
     mitk::IsoDoseLevelSet::Pointer clonedPreset = this->m_Presets[this->m_selectedPresetName]->Clone();
     mitk::IsoDoseLevelSetProperty::Pointer levelSetProp = mitk::IsoDoseLevelSetProperty::New(clonedPreset);
     selectedNode->SetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),levelSetProp);
 
 
     double hsvValue = 0.002778;
     float prescribed;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),prescribed);
 
     vtkSmartPointer<vtkColorTransferFunction> transferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
 
     mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
 
     MITK_INFO << "FUNCTION PRESCRIBE " << prescribed << endl;
 
 
     float pref;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
     mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
     //Generating the Colorwash
     for(mitk::IsoDoseLevelSet::ConstIterator setIT = isoDoseLevelSet->Begin(); setIT != isoDoseLevelSet->End(); ++setIT)
     {
       float *hsv = new float[3];
       //used for transfer rgb to hsv
       vtkSmartPointer<vtkMath> cCalc = vtkSmartPointer<vtkMath>::New();
       if(setIT->GetVisibleColorWash()){
         cCalc->RGBToHSV(setIT->GetColor()[0],setIT->GetColor()[1],setIT->GetColor()[2],&hsv[0],&hsv[1],&hsv[2]);
         transferFunction->AddHSVPoint(setIT->GetDoseValue()*pref,hsv[0],hsv[1],hsv[2],1.0,1.0);
       }
     }
 
     //Generating the standard isolines
     this->UpdateStdIsolines();
 
     mitk::TransferFunction::Pointer mitkTransFunc = mitk::TransferFunction::New();
     mitk::TransferFunctionProperty::Pointer mitkTransFuncProp = mitk::TransferFunctionProperty::New();
     mitkTransFunc->SetColorTransferFunction(transferFunction);
     mitkTransFuncProp->SetValue(mitkTransFunc);
 
     mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
     renderingMode->SetValue(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
     selectedNode->SetProperty("Image Rendering.Transfer Function", mitkTransFuncProp);
     selectedNode->SetProperty("Image Rendering.Mode", renderingMode);
     m_selectedNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
     mitk::IsoDoseLevelVector::Pointer levelVector = mitk::IsoDoseLevelVector::New();
     mitk::IsoDoseLevelVectorProperty::Pointer levelVecProp = mitk::IsoDoseLevelVectorProperty::New(levelVector);
     selectedNode->SetProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),levelVecProp);
 
     UpdateBySelectedNode();
 
 //    mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
 //    renderingMode->SetValue(mitk::RenderingModeProperty::ISODOSESHADER_COLOR);
 //    selectedNode->SetProperty("shader.mitkIsoLineShader.Gridscale", mitk::FloatProperty::New(10.0));
 //    selectedNode->SetProperty("Image Rendering.Mode", renderingMode);
 
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 //######################################################################################################
 const mitk::Geometry2D* RTDoseVisualizer::GetGeometry2D(char* dim)
 {
   QmitkRenderWindow* rw = this->GetRenderWindowPart()->GetQmitkRenderWindow(dim);
   const mitk::Geometry2D* worldGeo = rw->GetRenderer()->GetCurrentWorldGeometry2D();
   return worldGeo;
 }
 
 mitk::Image::Pointer RTDoseVisualizer::GetExtractedSlice(mitk::Image::Pointer image)
 {
   mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
   extractFilter->SetInput(image);
   extractFilter->SetWorldGeometry(this->GetGeometry2D("axial"));
   extractFilter->SetResliceTransformByGeometry( image->GetGeometry() );
   extractFilter->Update();
   mitk::Image::Pointer reslicedImage = extractFilter->GetOutput();
   return reslicedImage;
 }
 
 mitk::DataNode::Pointer RTDoseVisualizer::UpdatePolyData(int num, double min, double max)
 {
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
   vtkSmartPointer<vtkContourFilter> contourFilter = vtkSmartPointer<vtkContourFilter>::New();
   m_Filters.push_back(contourFilter);
   contourFilter->SetInput(reslicedImage->GetVtkImageData());
   contourFilter->GenerateValues(num,min,max);
   contourFilter->Update();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData =contourFilter->GetOutput();
 //  polyData->Print(std::cout);
 
   mitk::Surface::Pointer isoline = mitk::Surface::New();
   isoline->SetVtkPolyData(polyData);
   isoline->SetGeometry(const_cast<mitk::Geometry2D*>(this->GetGeometry2D("axial"))->Clone());
   isoline->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing());
   isoline->SetOrigin(reslicedImage->GetGeometry()->GetOrigin());
 
   mitk::DataNode::Pointer isolineNode = mitk::DataNode::New();
   isolineNode->SetData(isoline);
 //  mitk::PolyDataGLMapper2D::Pointer mapper = mitk::PolyDataGLMapper2D::New();
 //  mitk::SurfaceGLMapper2D::Pointer mapper = mitk::SurfaceGLMapper2D::New();
   mitk::SurfaceVtkMapper3D::Pointer mapper = mitk::SurfaceVtkMapper3D::New();
   isolineNode->SetMapper(1, mapper);
   isolineNode->SetName("Isoline1");
   isolineNode->SetBoolProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),true);
   this->GetDataStorage()->Add(isolineNode);
   return isolineNode;
 }
 
 void RTDoseVisualizer::UpdateStdIsolines()
 {
   mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = this->m_Presets[this->m_selectedPresetName];
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_selectedNode->GetData());
   mitk::Image::Pointer reslicedImage = this->GetExtractedSlice(image);
 
   float pref;
   m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);
 
   for(mitk::IsoDoseLevelSet::ConstIterator doseIT = isoDoseLevelSet->Begin(); doseIT!=isoDoseLevelSet->End();++doseIT)
   {
     if(doseIT->GetVisibleIsoLine()){
       vtkSmartPointer<vtkContourFilter> isolineFilter = vtkSmartPointer<vtkContourFilter>::New();
       isolineFilter->SetInput(reslicedImage->GetVtkImageData());
       isolineFilter->GenerateValues(1,doseIT->GetDoseValue()*pref,doseIT->GetDoseValue()*pref);
       isolineFilter->Update();
 
       vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
       polyData=isolineFilter->GetOutput();
 
       mitk::Surface::Pointer surface = mitk::Surface::New();
       surface->SetVtkPolyData(polyData);
       surface->SetGeometry(const_cast<mitk::Geometry2D*>(this->GetGeometry2D("axial"))->Clone());
       surface->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing());
       surface->SetOrigin(reslicedImage->GetGeometry()->GetOrigin());
 
       mitk::DataNode::Pointer isoNode = mitk::DataNode::New();
       isoNode->SetData(surface);
       mitk::SurfaceVtkMapper3D::Pointer mapper = mitk::SurfaceVtkMapper3D::New();
       mitk::Color color;
       color[0]=doseIT->GetColor()[0];color[1]=doseIT->GetColor()[1];color[2]=doseIT->GetColor()[2];
       isoNode->SetMapper(1,mapper);
       isoNode->SetColor(color);
       isoNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
       isoNode->SetName("StdIsoline");
       isoNode->SetBoolProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),true);
       this->GetDataStorage()->Add(isoNode);
     }
   }
 }
 
 void RTDoseVisualizer::HideIsoline()
 {
   mitk::NodePredicateProperty::Pointer isoProp = mitk::NodePredicateProperty::
       New(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
   mitk::DataStorage::SetOfObjects::ConstPointer isoSet =  this->GetDataStorage()->GetSubset(isoProp);
   for(mitk::DataStorage::SetOfObjects::ConstIterator iso = isoSet->Begin(); iso!=isoSet->End(); ++iso)
   {
   }
 }
 
 //######################################################################################################
 void RTDoseVisualizer::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
   const QList<mitk::DataNode::Pointer>& nodes )
 {
   QList<mitk::DataNode::Pointer> dataNodes = this->GetDataManagerSelection();
 
   mitk::DataNode* selectedNode = NULL;
 
   if (!dataNodes.empty())
   {
     bool isDoseNode = false;
     dataNodes[0]->GetBoolProperty(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(),isDoseNode);
 
     if (isDoseNode)
     {
       selectedNode = dataNodes[0];
     }
   }
 
   if (selectedNode != m_selectedNode.GetPointer())
   {
     m_selectedNode = selectedNode;
   }
 
   UpdateBySelectedNode();
 }
 
 void RTDoseVisualizer::UpdateBySelectedNode()
 {
   m_Controls.groupNodeSpecific->setEnabled(m_selectedNode.IsNotNull());
   m_Controls.groupFreeValues->setEnabled(m_selectedNode.IsNotNull());
 
   if(m_selectedNode.IsNull())
   {
     m_Controls.NrOfFractions->setText(QString("N/A. No dose selected"));
     m_Controls.prescribedDoseSpecific->setText(QString("N/A. No dose selected"));
     m_freeIsoValues = mitk::IsoDoseLevelVector::New();
     UpdateFreeIsoValues();
   }
   else
   {
     ///////////////////////////////////////////
     //dose specific information
     int fracCount = 1;
     m_selectedNode->GetIntProperty(mitk::rt::Constants::DOSE_FRACTION_COUNT_PROPERTY_NAME.c_str(),fracCount);
     m_Controls.NrOfFractions->setText(QString::number(fracCount));
 
     m_PrescribedDose_Data = 0.0;
 
     float tmp;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(),tmp);
     m_PrescribedDose_Data = (double)tmp;
 //    dynamic cast von float zu doubleproperty funktioniert nicht & getProperty von node->getData() funktioniert das ?
 //    mitk::DoubleProperty* propDouble = dynamic_cast<mitk::DoubleProperty*>(m_selectedNode->GetData()->GetProperty(mitk::rt::Constants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str()).GetPointer());
 //    if (propDouble)
 //    {
 //      m_PrescribedDose_Data = propDouble->GetValue();
 //    }
 
     m_Controls.prescribedDoseSpecific->setText(QString::number(m_PrescribedDose_Data));
 
     ///////////////////////////////////////////
     //free iso lines
     mitk::IsoDoseLevelVectorProperty::Pointer propIsoVector;
     m_selectedNode->GetProperty<mitk::IsoDoseLevelVectorProperty>(propIsoVector, mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str());
 
     if (propIsoVector.IsNull())
     {
       m_freeIsoValues = mitk::IsoDoseLevelVector::New();
       propIsoVector = mitk::IsoDoseLevelVectorProperty::New(m_freeIsoValues);
       m_selectedNode->SetProperty(mitk::rt::Constants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str(),propIsoVector);
     }
     else
     {
       m_freeIsoValues = propIsoVector->GetValue();
     }
 
     UpdateFreeIsoValues();
 
     ///////////////////////////////////////////
     //global dose issues
     bool showIsoLine = false;
     m_selectedNode->GetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(),showIsoLine);
     m_Controls.checkGlobalVisIsoLine->setChecked(showIsoLine);
 
     bool showColorWash = false;
     m_selectedNode->GetBoolProperty(mitk::rt::Constants::DOSE_SHOW_COLORWASH_PROPERTY_NAME.c_str(),showColorWash);
     m_Controls.checkGlobalVisColorWash->setChecked(showColorWash);
 
     float referenceDose = 0.0;
     m_selectedNode->GetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),referenceDose);
     m_Controls.spinReferenceDose->setValue(referenceDose);
 
     mitk::IsoDoseLevelSetProperty::Pointer propIsoSet =
       dynamic_cast<mitk::IsoDoseLevelSetProperty* >(m_selectedNode->GetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));
 
     if (propIsoSet)
     {
       this->m_selectedNodeIsoSet = propIsoSet->GetValue();
       this->m_LevelSetModel->setIsoDoseLevelSet(m_selectedNodeIsoSet);
     }
   }
 }
 
 void RTDoseVisualizer::UpdateByPreferences()
 {
   m_Presets = mitk::rt::LoadPresetsMap();
   m_internalUpdate = true;
   m_Controls.comboPresets->clear();
   this->m_selectedPresetName = mitk::rt::GetSelectedPresetName();
 
   int index = 0;
   int selectedIndex = -1;
   for (mitk::rt::PresetMapType::const_iterator pos = m_Presets.begin(); pos != m_Presets.end(); ++pos, ++index)
   {
     m_Controls.comboPresets->addItem(QString(pos->first.c_str()));
     if (this->m_selectedPresetName == pos->first)
     {
       selectedIndex = index;
     }
   }
 
   if (selectedIndex == -1)
   {
     selectedIndex = 0;
     MITK_WARN << "Error. Cannot iso dose level preset specified in preferences does not exist. Preset name: "<<this->m_selectedPresetName;
     this->m_selectedPresetName = m_Presets.begin()->first;
     mitk::rt::SetSelectedPresetName(this->m_selectedPresetName);
     MITK_INFO << "Changed selected iso dose level preset to first existing preset. New preset name: "<<this->m_selectedPresetName;
   }
 
   m_Controls.comboPresets->setCurrentIndex(selectedIndex);
 
   this->m_selectedNodeIsoSet = this->m_Presets[this->m_selectedPresetName];
   this->m_LevelSetModel->setIsoDoseLevelSet(m_selectedNodeIsoSet);
 
   mitk::DoseValueAbs referenceDose = 0.0;
   bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
   if (globalSync || this->m_selectedNode.IsNull())
   {
     m_Controls.spinReferenceDose->setValue(referenceDose);
   }
 
   bool displayAbsoluteDose = mitk::rt::GetDoseDisplayAbsolute();
   m_Controls.radioAbsDose->setChecked(displayAbsoluteDose);
   m_Controls.radioRelDose->setChecked(!displayAbsoluteDose);
   this->m_LevelSetModel->setShowAbsoluteDose(displayAbsoluteDose);
   m_internalUpdate = false;
 }
 
 void RTDoseVisualizer::OnCurrentPresetChanged(const QString& presetName)
 {
   if (!  m_internalUpdate)
   {
     mitk::rt::SetSelectedPresetName(presetName.toStdString());
     this->UpdateByPreferences();
     this->ActualizeIsoLevelsForAllDoseDataNodes();
     this->UpdateBySelectedNode();
   }
 }
 
 void RTDoseVisualizer::ActualizeIsoLevelsForAllDoseDataNodes()
 {
   std::string presetName = mitk::rt::GetSelectedPresetName();
 
   mitk::rt::PresetMapType presetMap = mitk::rt::LoadPresetsMap();
 
   mitk::NodePredicateProperty::Pointer isDoseNode = mitk::NodePredicateProperty::New(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(isDoseNode);
 
   mitk::IsoDoseLevelSet* selectedPreset = presetMap[presetName];
 
   if (!selectedPreset)
   {
     mitkThrow() << "Error. Cannot actualize iso dose level preset. Selected preset idoes not exist. Preset name: "<<presetName;
   }
 
   for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
   {
     mitk::IsoDoseLevelSet::Pointer clonedPreset = selectedPreset->Clone();
     mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = mitk::IsoDoseLevelSetProperty::New(clonedPreset);
     (*pos)->SetProperty(mitk::rt::Constants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str(),propIsoSet);
   }
 }
 
 void RTDoseVisualizer::ActualizeReferenceDoseForAllDoseDataNodes()
 {
   /** @TODO Klären ob diese präsentations info genauso wie*/
   mitk::DoseValueAbs value = 0;
   bool sync = mitk::rt::GetReferenceDoseValue(value);
 
   if (sync)
   {
     mitk::NodePredicateProperty::Pointer isDoseNode = mitk::NodePredicateProperty::New(mitk::rt::Constants::DOSE_PROPERTY_NAME.c_str(), mitk::BoolProperty::New(true));
 
     mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(isDoseNode);
 
     for(mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end(); ++pos)
     {
       (*pos)->SetFloatProperty(mitk::rt::Constants::REFERENCE_DOSE_PROPERTY_NAME.c_str(), value);
     }
   }
 }
 
 void RTDoseVisualizer::ActualizeDisplayStyleForAllDoseDataNodes()
 {
   /** @TODO Klären ob diese präsentations info global oder auch per node gespeichert wird*/
 }
 
 void RTDoseVisualizer::OnHandleCTKEventReferenceDoseChanged(const ctkEvent& event)
 {
   mitk::DoseValueAbs referenceDose = 0.0;
   bool globalSync = mitk::rt::GetReferenceDoseValue(referenceDose);
 
   this->m_Controls.spinReferenceDose->setValue(referenceDose);
 }
 
 void RTDoseVisualizer::OnHandleCTKEventPresetsChanged(const ctkEvent& event)
 {
   std::string currentPresetName  = mitk::rt::GetSelectedPresetName();
 
   this->OnCurrentPresetChanged(QString::fromStdString(currentPresetName));
 }
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.h b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.h
index a6b62e8615..83b7871996 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.h
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizer.h
@@ -1,166 +1,168 @@
 /*===================================================================
 
 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 RTDoseVisualizer_h
 #define RTDoseVisualizer_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include <mitkDataNodeFactory.h>
 
 #include <mitkDicomRTReader.h>
 
 #include "ui_RTDoseVisualizerControls.h"
 
 #include <mitkIsoDoseLevelCollections.h>
 
 #include <mitkImage.h>
 
 #include "mitkDoseVisPreferenceHelper.h"
 
 // Shader
 #include <mitkCoreServices.h>
 #include <mitkIShaderRepository.h>
 #include <mitkShaderProperty.h>
 
 #include <vtkContourFilter.h>
 
 /*forward declarations*/
 class QmitkIsoDoseLevelSetModel;
 class QmitkDoseColorDelegate;
 class QmitkDoseValueDelegate;
 class QmitkDoseVisualStyleDelegate;
 class ctkEvent;
 
 /**
 \brief RTDoseVisualizer
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkAbstractView
 \ingroup ${plugin_target}_internal
 */
 class RTDoseVisualizer : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   RTDoseVisualizer();
   virtual ~RTDoseVisualizer();
   static const std::string VIEW_ID;
 
+  void OnSliceChanged(itk::Object *sender, const itk::EventObject &e);
+
   protected slots:
 
     void OnConvertButtonClicked();
 
     void OnAddFreeValueClicked();
 
     void OnRemoveFreeValueClicked();
 
     void OnUsePrescribedDoseClicked();
 
     void OnAbsDoseToggled(bool);
 
     void OnGlobalVisColorWashToggled(bool);
 
     void OnGlobalVisIsoLineToggled(bool);
 
     void OnShowContextMenuIsoSet(const QPoint&);
 
     void OnCurrentPresetChanged(const QString&);
 
     void OnReferenceDoseChanged(double);
 
     void OnHandleCTKEventReferenceDoseChanged(const ctkEvent& event);
 
     void OnHandleCTKEventPresetsChanged(const ctkEvent& event);
 
     void UpdateFreeIsoLine(mitk::IsoDoseLevel*level, mitk::DoseValueRel old);
 
 protected:
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void SetFocus();
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes );
 
   /** Method updates the list widget according to the current m_freeIsoValues.*/
   void UpdateFreeIsoValues();
 
   /** Update the members according to the currently selected node */
   void UpdateBySelectedNode();
 
   /** Update the member widgets according to the information stored in the application preferences*/
   void UpdateByPreferences();
 
   /**helper function that iterates throug all data nodes and sets there iso level set property
   according to the selected preset.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeIsoLevelsForAllDoseDataNodes();
 
   /**helper function that iterates throug all data nodes and sets there reference dose value
   according to the preference.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeReferenceDoseForAllDoseDataNodes();
 
   /**helper function that iterates through all data nodes and sets there dose display style (relative/absolute)
   according to the preference.
   @TODO: should be moved outside the class, to be available for other classes at well.*/
   void ActualizeDisplayStyleForAllDoseDataNodes();
 
   mitk::DataNode::Pointer UpdatePolyData(int num, double min, double max);
   void UpdateStdIsolines();
   void HideIsoline();
   mitk::Image::Pointer GetExtractedSlice(mitk::Image::Pointer image);
   const mitk::Geometry2D* GetGeometry2D(char* dim);
 
   Ui::RTDoseVisualizerControls m_Controls;
   mitk::DataNode::Pointer m_selectedNode;
   mitk::IsoDoseLevelVector::Pointer m_freeIsoValues;
   std::vector<mitk::DataNode::Pointer> m_FreeIsoLines;
   /** Iso level set of the current node. Should normaly be a clone of the
   * current iso preset. It held as own member because visibility
   * settings may differ.*/
   mitk::IsoDoseLevelSet::Pointer m_selectedNodeIsoSet;
   mitk::rt::PresetMapType m_Presets;
   std::string m_selectedPresetName;
 
   mitk::DataNode::Pointer m_FreeIsoline;
 
   /** Prescribed Dose of the selected data.*/
   mitk::DoseValueAbs m_PrescribedDose_Data;
 
   QmitkIsoDoseLevelSetModel* m_LevelSetModel;
   QmitkDoseColorDelegate* m_DoseColorDelegate;
   QmitkDoseValueDelegate* m_DoseValueDelegate;
   QmitkDoseVisualStyleDelegate* m_DoseVisualDelegate;
 
   vtkSmartPointer<vtkContourFilter> m_freeIsoFilter;
   std::vector< vtkSmartPointer<vtkContourFilter> > m_Filters;
 
 
   bool m_internalUpdate;
 };
 
 #endif // RTDoseVisualizer_h
diff --git a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizerControls.ui b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizerControls.ui
index 7503602792..091d7664c1 100644
--- a/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizerControls.ui
+++ b/Plugins/org.mitk.gui.qt.rt.dosevisualization/src/internal/RTDoseVisualizerControls.ui
@@ -1,505 +1,508 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>RTDoseVisualizerControls</class>
  <widget class="QWidget" name="RTDoseVisualizerControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>421</width>
     <height>651</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>5</number>
    </property>
    <property name="leftMargin">
     <number>5</number>
    </property>
    <property name="topMargin">
     <number>5</number>
    </property>
    <property name="rightMargin">
     <number>5</number>
    </property>
    <property name="bottomMargin">
     <number>5</number>
    </property>
    <item>
     <widget class="QGroupBox" name="groupNodeSpecific">
      <property name="title">
       <string>Dose specific information:</string>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout_2">
       <property name="spacing">
        <number>5</number>
       </property>
       <property name="leftMargin">
        <number>5</number>
       </property>
       <property name="topMargin">
        <number>5</number>
       </property>
       <property name="rightMargin">
        <number>5</number>
       </property>
       <property name="bottomMargin">
        <number>5</number>
       </property>
       <item>
        <layout class="QGridLayout" name="gridLayout_2">
         <item row="1" column="4">
          <spacer name="horizontalSpacer_3">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="1" column="2">
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <item>
            <widget class="QLineEdit" name="prescribedDoseSpecific">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>30 Gy</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
             </property>
             <property name="readOnly">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item row="0" column="0">
          <widget class="QLabel" name="label">
           <property name="text">
            <string>Number of fractions:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="QLabel" name="label_4">
           <property name="text">
            <string>Prescribed dose [Gy]:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="3">
          <widget class="QPushButton" name="btnUsePrescribedDose">
           <property name="text">
            <string>Use as reference dose</string>
           </property>
          </widget>
         </item>
         <item row="0" column="2">
          <widget class="QLineEdit" name="NrOfFractions">
           <property name="readOnly">
            <bool>true</bool>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupFreeValues">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Free iso lines:</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <property name="spacing">
        <number>5</number>
       </property>
       <property name="leftMargin">
        <number>5</number>
       </property>
       <property name="topMargin">
        <number>5</number>
       </property>
       <property name="rightMargin">
        <number>5</number>
       </property>
       <property name="bottomMargin">
        <number>5</number>
       </property>
       <item>
        <widget class="QListWidget" name="listFreeValues">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>40</height>
          </size>
         </property>
         <property name="maximumSize">
          <size>
           <width>16777215</width>
           <height>110</height>
          </size>
         </property>
         <property name="gridSize">
          <size>
           <width>0</width>
           <height>25</height>
          </size>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_4">
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QPushButton" name="btnAddFreeValue">
           <property name="text">
            <string>Add</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="btnRemoveFreeValue">
           <property name="text">
            <string>Remove</string>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupGlobal">
      <property name="title">
       <string>Global iso dose visualization:</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <property name="spacing">
        <number>5</number>
       </property>
       <property name="leftMargin">
        <number>5</number>
       </property>
       <property name="topMargin">
        <number>5</number>
       </property>
       <property name="rightMargin">
        <number>5</number>
       </property>
       <property name="bottomMargin">
        <number>5</number>
       </property>
       <item>
        <layout class="QGridLayout" name="gridLayout">
         <item row="3" column="0">
          <widget class="QLabel" name="label_3">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>65</width>
             <height>0</height>
            </size>
           </property>
           <property name="text">
            <string>Dose display:</string>
           </property>
          </widget>
         </item>
         <item row="5" column="1">
          <widget class="QComboBox" name="comboPresets"/>
         </item>
         <item row="5" column="0">
          <widget class="QLabel" name="label_2">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>65</width>
             <height>0</height>
            </size>
           </property>
           <property name="text">
            <string>Preset style:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="0">
          <widget class="QLabel" name="lblinfo_2">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>105</width>
             <height>0</height>
            </size>
           </property>
           <property name="focusPolicy">
            <enum>Qt::NoFocus</enum>
           </property>
           <property name="text">
            <string>Reference dose [Gy]:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="QDoubleSpinBox" name="spinReferenceDose">
           <property name="suffix">
            <string/>
           </property>
           <property name="decimals">
            <number>1</number>
           </property>
           <property name="minimum">
            <double>0.100000000000000</double>
           </property>
           <property name="maximum">
            <double>9999.000000000000000</double>
           </property>
           <property name="value">
-           <double>0.000000000000000</double>
+           <double>0.100000000000000</double>
           </property>
          </widget>
         </item>
         <item row="3" column="1">
          <layout class="QHBoxLayout" name="horizontalLayout">
           <item>
            <widget class="QRadioButton" name="radioRelDose">
             <property name="text">
              <string>relative [%]</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioAbsDose">
             <property name="text">
              <string>absolute [Gy]</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
        </layout>
       </item>
       <item>
        <widget class="QTableView" name="isoLevelSetView">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
         <property name="alternatingRowColors">
          <bool>true</bool>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::SingleSelection</enum>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
         <property name="iconSize">
          <size>
           <width>30</width>
           <height>20</height>
          </size>
         </property>
         <attribute name="horizontalHeaderDefaultSectionSize">
          <number>80</number>
         </attribute>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_5">
         <item>
          <widget class="QLabel" name="label_5">
           <property name="text">
            <string>Global visibility:</string>
           </property>
          </widget>
         </item>
         <item>
          <spacer name="horizontalSpacer_2">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QCheckBox" name="checkGlobalVisIsoLine">
           <property name="text">
            <string>Isolines</string>
           </property>
           <property name="icon">
            <iconset>
             <normalon>:/RTUI/eye_open.png</normalon>
            </iconset>
           </property>
           <property name="iconSize">
            <size>
             <width>24</width>
             <height>16</height>
            </size>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QCheckBox" name="checkGlobalVisColorWash">
           <property name="text">
            <string>Colorwash</string>
           </property>
           <property name="icon">
            <iconset>
             <normalon>:/RTUI/eye_open.png</normalon>
            </iconset>
           </property>
           <property name="iconSize">
            <size>
             <width>24</width>
             <height>16</height>
            </size>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="btnConvert">
      <property name="palette">
       <palette>
        <active>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>255</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>255</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </active>
        <inactive>
         <colorrole role="Text">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>255</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
         <colorrole role="ButtonText">
          <brush brushstyle="SolidPattern">
           <color alpha="255">
            <red>255</red>
            <green>0</green>
            <blue>0</blue>
           </color>
          </brush>
         </colorrole>
        </inactive>
        <disabled>
         <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>Convert nod to dose node (for testing only!)</string>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>