diff --git a/Examples/Tutorial/Step3/Step3.cpp b/Examples/Tutorial/Step3/Step3.cpp
index 33cf669ec4..3c93792ac2 100644
--- a/Examples/Tutorial/Step3/Step3.cpp
+++ b/Examples/Tutorial/Step3/Step3.cpp
@@ -1,161 +1,164 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 
 #include <mitkStandaloneDataStorage.h>
 #include <mitkProperties.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkRenderingManager.h>
 #include <mitkIOUtil.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <QApplication>
 
 
 //##Documentation
 //## @brief Change the type of display to 3D
 //##
 //## As in Step2, load one or more data sets (many image, surface
 //## and other formats), but display it in a 3D view.
 //## The QmitkRenderWindow is now used for displaying a 3D view, by
 //## setting the used mapper-slot to Standard3D.
 //## Since volume-rendering is a (rather) slow procedure, the default
 //## is that images are not displayed in the 3D view. For this example,
 //## we want volume-rendering, thus we switch it on by setting
 //## the Boolean-property "volumerendering" to "true".
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
       //*********************************************************************
       // Part III: Put the data into the datastorage
       //*********************************************************************
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*ds);
 
 
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
     mitk::DataNode::Pointer node = dataNodes->at(0);
 
       // *********************************************************
       // ****************** START OF NEW PART 1 ******************
       // *********************************************************
 
       //*********************************************************************
       // Part IV: We want all images to be volume-rendered
       //*********************************************************************
 
       // Check if the data is an image by dynamic_cast-ing the data
       // contained in the node. Warning: dynamic_cast's are rather slow,
       // do not use it too often!
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
       if(image.IsNotNull())
       {
         // Set the property "volumerendering" to the Boolean value "true"
         node->SetProperty("volumerendering", mitk::BoolProperty::New(true));
 
         // Create a transfer function to assign optical properties (color and opacity) to grey-values of the data
         mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
         tf->InitializeByMitkImage ( image );
 
         // Set the color transfer function AddRGBPoint(double x, double r, double g, double b)
         tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [0], 1.0, 0.0, 0.0 );
         tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1.0, 1.0, 0.0 );
 
         // Set the piecewise opacity transfer function AddPoint(double x, double y)
         tf->GetScalarOpacityFunction()->AddPoint ( 0, 0 );
         tf->GetScalarOpacityFunction()->AddPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1 );
 
         node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
       }
 
 
       // *********************************************************
       // ******************* END OF NEW PART 1 *******************
       // *********************************************************
   }
 
   //*************************************************************************
   // Part V: Create window and pass the tree to it
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow;
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // *********************************************************
   // ****************** START OF NEW PART 2 ******************
   // *********************************************************
   // Use it as a 3D view!
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
+  // Reposition the camera to include all visible actors
+  renderWindow.GetRenderer()->GetVtkRenderer()->ResetCamera();
+
   // *********************************************************
   // ******************* END OF NEW PART 2 *******************
   // *********************************************************
 
   //*************************************************************************
   // Part VI: Qt-specific initialization
   //*************************************************************************
   renderWindow.show();
   renderWindow.resize( 256, 256 );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step3.cpp
 */
diff --git a/Examples/Tutorial/Step4/Step4.cpp b/Examples/Tutorial/Step4/Step4.cpp
index 6b2c0f1700..03f05d39ef 100644
--- a/Examples/Tutorial/Step4/Step4.cpp
+++ b/Examples/Tutorial/Step4/Step4.cpp
@@ -1,170 +1,173 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkNodePredicateDataType.h"
 #include <mitkIOUtil.h>
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
 #include <mitkImage.h>
 
 //##Documentation
 //## @brief Use several views to explore data
 //##
 //## As in Step2 and Step3, load one or more data sets (many image,
 //## surface and other formats), but create 3 views on the data.
 //## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
 //## but without volume-rendering.
 //## Furthermore, we create two 2D views for slicing through the data.
 //## We use the class QmitkSliceWidget, which is based on the class
 //## QmitkRenderWindow, but additionally provides sliders
 //## to slice through the data. We create two instances of
 //## QmitkSliceWidget, one for axial and one for sagittal slicing.
 //## The two slices are also shown at their correct position in 3D as
 //## well as intersection-line, each in the other 2D view.
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
     //*********************************************************************
     // Part III: Put the data into the datastorage
     //*********************************************************************
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::IOUtil::Load(argv[i],*ds);
   }
 
   //*************************************************************************
   // Part IV: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part IVa: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
+  // Reposition the camera to include all visible actors
+  renderWindow.GetRenderer()->GetVtkRenderer()->ResetCamera();
+
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part IVb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
   view2.SetLevelWindowEnabled(true);
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
 
   // Get the image from the data storage. A predicate (mitk::NodePredicateBase)
   // is used to get only nodes of the type mitk::Image.
   mitk::DataStorage::SetOfObjects::ConstPointer rs =
       ds->GetSubset(mitk::TNodePredicateDataType<mitk::Image>::New());
 
   view2.SetData(rs->Begin(),mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part IVc: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
   view3.SetDataStorage(ds);
   // Tell the QmitkSliceWidget which (part of) the datastorage to render
   // and to slice sagitally
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step4.cpp
 */
diff --git a/Examples/Tutorial/Step5/Step5.cpp b/Examples/Tutorial/Step5/Step5.cpp
index 81b4fcc41c..a2ebd1c1df 100644
--- a/Examples/Tutorial/Step5/Step5.cpp
+++ b/Examples/Tutorial/Step5/Step5.cpp
@@ -1,209 +1,212 @@
 /*===================================================================
 
 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 "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 
 #include "mitkPointSet.h"
 // NEW INCLUDE
 #include "mitkPointSetDataInteractor.h"
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
 #include <mitkIOUtil.h>
 
 //##Documentation
 //## @brief Interactively add points
 //##
 //## As in Step4, load one or more data sets (many image,
 //## surface and other formats) and create 3 views on the data.
 //## Additionally, we want to interactively add points. A node containing
 //## a PointSet as data is added to the data tree and a PointSetDataInteractor
 //## is associated with the node, which handles the interaction. The
 //## @em interaction @em pattern is defined in a state-machine, stored in an
 //## external XML file. Thus, we need to load a state-machine
 //## The interaction patterns defines the @em events,
 //## on which the interactor reacts (e.g., which mouse buttons are used to
 //## set a point), the @em transition to the next state (e.g., the initial
 //## may be "empty point set") and associated @a actions (e.g., add a point
 //## at the position where the mouse-click occured).
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*ds);
 
     //*********************************************************************
     // Part III: Put the data into the datastorage
     //*********************************************************************
     // Add the node to the DataStorage
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part V: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part Va: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
 
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
+  // Reposition the camera to include all visible actors
+  renderWindow.GetRenderer()->GetVtkRenderer()->ResetCamera();
+
   //*************************************************************************
   // Part Vb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetAll();
   view2.SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part Vc: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
   // and to slice sagitall
   view3.SetDataStorage(ds);
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part VI: For allowing to interactively add points ...
   //*************************************************************************
 
 
   // ATTENTION: It is very important that the renderer already know their DataStorage,
   // because registerig DataInteractors with the render windows is done automatically
   // and only works if the BaseRenderer and the DataStorage know each other.
 
   // Create PointSet and a node for it
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   // Store the point set in the DataNode
   pointSetNode->SetData(pointSet);
 
   // Add the node to the tree
   ds->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   // Set the StateMachine pattern that describes the flow of the interactions
   interactor->LoadStateMachine("PointSet.xml");
   // Set the configuration file, which describes the user interactions that trigger actions
   // in this file SHIFT + LeftClick triggers add Point, but by modifying this file,
   // it could as well be changes to any other user interaction.
   interactor->SetEventConfig("PointSetConfig.xml");
 
   // Assign the pointSetNode to the interactor,
   // alternatively one could also add the DataInteractor to the pointSetNode using the SetDataInteractor() method.
   interactor->SetDataNode(pointSetNode);
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
 
 
   //*************************************************************************
   //Part VII: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   // For testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 /**
 \example Step5.cpp
 */
diff --git a/Examples/Tutorial/Step6/Step6.cpp b/Examples/Tutorial/Step6/Step6.cpp
index acff49c596..01c1d2023d 100644
--- a/Examples/Tutorial/Step6/Step6.cpp
+++ b/Examples/Tutorial/Step6/Step6.cpp
@@ -1,236 +1,239 @@
 /*===================================================================
 
 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 "Step6.h"
 
 #include "QmitkRenderWindow.h"
 #include "QmitkSliceWidget.h"
 
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkPointSet.h"
 #include "mitkPointSetDataInteractor.h"
 
 #include "mitkImageAccessByItk.h"
 
 #include "mitkRenderingManager.h"
 #include <mitkIOUtil.h>
 
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 
 //##Documentation
 //## @brief Start region-grower at interactively added points
 Step6::Step6(int argc, char* argv[], QWidget *parent)
 : QWidget(parent)
 {
   // load data as in the previous steps; a reference to the first loaded
   // image is kept in the member m_FirstImage and used as input for the
   // region growing
   Load(argc, argv);
 }
 
 void Step6::Initialize()
 {
   // setup the widgets as in the previous steps, but with an additional
   // QVBox for a button to start the segmentation
   this->SetupWidgets();
 
   // Create controlsParent widget with horizontal layout
   QWidget *controlsParent = new QWidget(this);
   this->layout()->addWidget(controlsParent);
 
   QHBoxLayout* hlayout = new QHBoxLayout(controlsParent);
   hlayout->setSpacing(2);
 
   QLabel *labelThresholdMin = new QLabel("Lower Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMin);
 
   m_LineEditThresholdMin = new QLineEdit("-1000", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMin);
 
   QLabel *labelThresholdMax = new QLabel("Upper Threshold:", controlsParent);
   hlayout->addWidget(labelThresholdMax);
 
   m_LineEditThresholdMax = new QLineEdit("-400", controlsParent);
   hlayout->addWidget(m_LineEditThresholdMax);
 
   // create button to start the segmentation and connect its clicked()
   // signal to method StartRegionGrowing
   QPushButton* startButton = new QPushButton("start region growing",
       controlsParent);
   hlayout->addWidget(startButton);
 
   connect(startButton, SIGNAL(clicked()), this, SLOT(StartRegionGrowing()));
   if (m_FirstImage.IsNull())
     startButton->setEnabled(false);
 
   // as in Step5, create PointSet (now as a member m_Seeds) and
   // associate a interactor to it
 
   m_Seeds = mitk::PointSet::New();
   mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
   pointSetNode->SetData(m_Seeds);
   pointSetNode->SetProperty("layer", mitk::IntProperty::New(2));
   m_DataStorage->Add(pointSetNode);
 
   // Create PointSetDataInteractor
   mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New();
   interactor->LoadStateMachine("PointSet.xml");
   interactor->SetEventConfig("PointSetConfig.xml");
   interactor->SetDataNode(pointSetNode);
 }
 
 int Step6::GetThresholdMin()
 {
   return m_LineEditThresholdMin->text().toInt();
 }
 
 int Step6::GetThresholdMax()
 {
   return m_LineEditThresholdMax->text().toInt();
 }
 
 void Step6::StartRegionGrowing()
 {
   AccessByItk_1(m_FirstImage, RegionGrowing, this);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void Step6::Load(int argc, char* argv[])
 {
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   m_DataStorage = mitk::StandaloneDataStorage::New();
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for (i = 1; i < argc; ++i)
   {
     // For testing
     if (strcmp(argv[i], "-testing") == 0)
       continue;
 
     // Load datanode (eg. many image formats, surface formats, etc.)
     mitk::StandaloneDataStorage::SetOfObjects::Pointer dataNodes = mitk::IOUtil::Load(argv[i],*m_DataStorage);
 
     if(dataNodes->empty())
     {
       fprintf( stderr, "Could not open file %s \n\n", argv[i] );
       exit(2);
     }
 
     mitk::Image::Pointer image =  dynamic_cast<mitk::Image*> (dataNodes->at(0)->GetData());
     if ((m_FirstImage.IsNull()) && (image.IsNotNull()))
       m_FirstImage = image;
   }
 }
 
 void Step6::SetupWidgets()
 {
   //*************************************************************************
   // Part I: Create windows and pass the datastorage to it
   //*************************************************************************
 
   // Create toplevel widget with vertical layout
   QVBoxLayout* vlayout = new QVBoxLayout(this);
   vlayout->setMargin(0);
   vlayout->setSpacing(2);
 
   // Create viewParent widget with horizontal layout
   QWidget* viewParent = new QWidget(this);
   vlayout->addWidget(viewParent);
 
   QHBoxLayout* hlayout = new QHBoxLayout(viewParent);
   hlayout->setMargin(0);
   hlayout->setSpacing(2);
 
   //*************************************************************************
   // Part Ia: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow* renderWindow = new QmitkRenderWindow(viewParent);
   hlayout->addWidget(renderWindow);
 
   // Tell the renderwindow which (part of) the tree to render
   renderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
 
   // Use it as a 3D view
   renderWindow->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
+  // Reposition the camera to include all visible actors
+  renderWindow->GetRenderer()->GetVtkRenderer()->ResetCamera();
+
   //*************************************************************************
   // Part Ib: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view2 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view2);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2->SetDataStorage(m_DataStorage);
   mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
   view2->SetData(rs->Begin(), mitk::SliceNavigationController::Axial);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view2->GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part Ic: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget *view3 = new QmitkSliceWidget(viewParent);
   hlayout->addWidget(view3);
 
   // Tell the QmitkSliceWidget which (part of) the tree to render
   // and to slice sagitally
   view3->SetDataStorage(m_DataStorage);
   view3->SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
 
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the tree!
   m_DataStorage->Add(view3->GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part II: handle updates: To avoid unnecessary updates, we have to
   //*************************************************************************
   // define when to update. The RenderingManager serves this purpose, and
   // each RenderWindow has to be registered to it.
   /*mitk::RenderingManager *renderingManager =
    mitk::RenderingManager::GetInstance();
    renderingManager->AddRenderWindow( renderWindow );
    renderingManager->AddRenderWindow( view2->GetRenderWindow() );
    renderingManager->AddRenderWindow( view3->GetRenderWindow() );*/
 }
 
 /**
  \example Step6.cpp
  */