diff --git a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.cpp b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.cpp
index 9fc1aa7fa9..b12c04353a 100755
--- a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.cpp
+++ b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.cpp
@@ -1,339 +1,370 @@
 /*===================================================================
 
 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 "QmitkPythonVariableStackTableModel.h"
 #include <QMimeData>
 #include <mitkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkIOUtil.h>
 #include <mitkDataNode.h>
 #include <QDir>
 #include <QDateTime>
 #include "mitkPluginActivator.h"
 #include <ctkAbstractPythonManager.h>
 
 
 QmitkPythonVariableStackTableModel::QmitkPythonVariableStackTableModel(QObject *parent)
     :QAbstractTableModel(parent)
 {
 }
 
 QmitkPythonVariableStackTableModel::~QmitkPythonVariableStackTableModel()
 {
 }
 
 bool QmitkPythonVariableStackTableModel::dropMimeData ( const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent )
 {
     // Early exit, returning true, but not actually doing anything (ignoring data).
     if (action == Qt::IgnoreAction)
         return true;
 
     // Note, we are returning true if we handled it, and false otherwise
     bool returnValue = false;
 
     if(data->hasFormat("application/x-mitk-datanodes"))
     {
         MITK_INFO << "dropped MITK DataNode";
         returnValue = true;
 
         QString arg = QString(data->data("application/x-mitk-datanodes").data());
         QStringList listOfDataNodeAddressPointers = arg.split(",");
 
         QStringList::iterator slIter;
         for (slIter = listOfDataNodeAddressPointers.begin();
              slIter != listOfDataNodeAddressPointers.end();
              slIter++)
         {
           long val = (*slIter).toLong();
           mitk::DataNode* node = static_cast<mitk::DataNode *>((void*)val);
           mitk::Image* mitkImage = dynamic_cast<mitk::Image*>(node->GetData());
 
           // save image
           QString tmpFolder = QDir::tempPath();
-          QDateTime dateTime = QDateTime::currentDateTime();
-          QString fileName = tmpFolder + QDir::separator() + dateTime.toString("yy.MM.dd.hh.ss.zzz") + ".nrrd";
+          QString nodeName = QString::fromStdString(node->GetName());
+          QString fileName = tmpFolder + QDir::separator() + nodeName + ".nrrd";
 
           MITK_INFO << "Saving temporary file " << fileName.toStdString();
           if( !mitk::IOUtil::SaveImage(mitkImage, fileName.toStdString()) )
           {
               MITK_ERROR << "Temporary file could not be created.";
           }
 
           QString command;
           command.append("import itk\n");
-          command.append("dim = 3\n");
-          command.append("pixelType = itk.UC\n");
-          command.append("imageType = itk.Image[pixelType, dim]\n");
-          command.append("readerType = itk.ImageFileReader[imageType]\n");
-          command.append("reader = readerType.New()\n");
-          command.append(QString("reader.SetFileName( \"%1\" )\n").arg(fileName));
+          command.append( QString("dim_%1 = 3\n").arg( nodeName ) );
+          command.append( QString("pixelType_%1 = itk.US\n").arg( nodeName ) );
+          command.append( QString("imageType_%1 = itk.Image[pixelType_%2, dim_%3]\n").arg( nodeName ).arg( nodeName ).arg( nodeName ) );
+          command.append( QString("readerType = itk.ImageFileReader[imageType_%1]\n").arg( nodeName ) );
+          command.append( "reader = readerType.New()\n" );
+          command.append( QString("reader.SetFileName( \"%1\" )\n").arg(fileName) );
           command.append("reader.Update()\n");
-          command.append("itkImage = reader.GetOutput()\n");
+          command.append( QString("image_%1 = reader.GetOutput()\n").arg( nodeName ).arg( nodeName ) );
           MITK_INFO << "Issuing python command " << command.toStdString();
           mitk::PluginActivator::GetPythonManager()->executeString(command, ctkAbstractPythonManager::FileInput );
           this->Update();
 
           QFile file(fileName);
           MITK_INFO << "Removing file " << fileName.toStdString();
           file.remove();
 
           /*
           if( mitkImage )
           {
               MITK_INFO << "found MITK image";
               switch(mitkImage->GetDimension())
               {
                   case 2:
                     {
                       AccessFixedDimensionByItk( mitkImage, ItkImageProcessing, 2 ); break;
                     }
                   case 3:
                     {
                       AccessFixedDimensionByItk( mitkImage, ItkImageProcessing, 3 ); break;
                     }
                   case 4:
                     {
                       AccessFixedDimensionByItk( mitkImage, ItkImageProcessing, 4 ); break;
                     }
                   default: break;
               }
           }
           itk::SmartPointer<mitk::DataNode > * resultptr;
           resultptr = new itk::SmartPointer<mitk::DataNode >((itk::SmartPointer<mitk::DataNode > &)node);
 
           if(resultptr)
           {
               int i = 0;
               while(swig_types_initial[i] != 0)
               {
                 if(swig_types_initial[i] == _swigt__p_itk__SmartPointerTmitk__DataNode_t)
                   SWIGTYPE_p_itk__SmartPointerTmitk__DataNode_t = SWIG_TypeRegister(swig_types_initial[i]);
                 i++;
               }
 
               PyObject * resultObj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_itk__SmartPointerTmitk__DataNode_t, 1);
               PyObject* dict = PyImport_GetModuleDict();
               PyObject* object = PyDict_GetItemString(dict, "__main__");
 
               if(object){
                   Py_INCREF(object);
                   PyModule_AddObject(object, node->GetName().c_str(), resultObj);
               }
               setVariableStack(this->getAttributeList());
           }
           */
         }
     }
     return returnValue;
 }
 
 QVariant QmitkPythonVariableStackTableModel::headerData(int section, Qt::Orientation orientation,
                                                         int role) const
 {
     QVariant headerData;
 
     // show only horizontal header
     if ( role == Qt::DisplayRole )
     {
         if( orientation == Qt::Horizontal )
         {
             // first column: "Attribute"
             if(section == 0)
                 headerData = "Attribute";
             else if(section == 1)
                 headerData = "Value";
             else if(section == 2)
                 headerData = "Type";
         }
     }
 
     return headerData;
 }
 
 Qt::ItemFlags QmitkPythonVariableStackTableModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
     if(index.isValid())
         return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | flags;
     else
         return Qt::ItemIsDropEnabled | flags;
 }
 
 int QmitkPythonVariableStackTableModel::rowCount(const QModelIndex &) const
 {
     return m_VariableStack.size();
 }
 
 int QmitkPythonVariableStackTableModel::columnCount(const QModelIndex &) const
 {
     return 3;
 }
 
 QVariant QmitkPythonVariableStackTableModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid() && !m_VariableStack.empty())
     {
         if(role == Qt::DisplayRole)
         {
             QStringList item = m_VariableStack.at(index.row());
             if(index.column() == 0)
                 return item[0];
             if(index.column() == 1)
                 return item[1];
             if(index.column() == 2)
                 return item[2];
         }
     }
     return QVariant();
 }
 
 void QmitkPythonVariableStackTableModel::clear()
 {
     m_VariableStack.clear();
     QAbstractTableModel::reset();
 }
 
 void QmitkPythonVariableStackTableModel::setVariableStack(QList<QStringList> varStack)
 {
     m_VariableStack = varStack;
     QAbstractTableModel::reset();
 }
 
+QList<QStringList> QmitkPythonVariableStackTableModel::getVariableStack()
+{
+    return m_VariableStack;
+}
+
+/*
 QMimeData * QmitkPythonVariableStackTableModel::mimeData(const QModelIndexList & indexes) const
 {
-    return QAbstractTableModel::mimeData(indexes);
+    QMimeData * ret = new QMimeData;
+
+    QString command;
+    QString tmpFolder = QDir::tempPath();
+    for (int indexesCounter = 0; indexesCounter < indexes.size(); indexesCounter++)
+    {
+      QString name = m_VariableStack[indexes.at(indexesCounter).row()][0];
+      QString fileName = tmpFolder + QDir::separator() + name + ".nrrd";
+
+      MITK_INFO << "Saving temporary file with python itk code " << fileName.toStdString();
+      command.append("import itk\n");
+      command.append("writer = itk.ImageFileWriter[ image ].New()\n");
+      command.append( QString( "reader.SetFileName( \"%1\" )\n").arg(fileName) );
+      command.append( QString( "writer.SetInput( \"%1\" )\n").arg(fileName) );
+      command.append("writer.Update()\n");
+
+      MITK_INFO << "Loading temporary file " << fileName.toStdString() << " as MITK image";
+      mitk::Image::Pointer mitkImage = mitk::IOUtil::LoadImage( fileName.toStdString() );
+
+      if( mitkImage.IsNotNull() )
+      {
+      }
+      else
+      {
+          MITK_ERROR << "Temporary image could not be written or was invalid.";
+      }
+    }
+
+    return ret;
 
     /*
     QMimeData * ret = new QMimeData;
 
     QString dataNodeAddresses("");
 
     for (int indexesCounter = 0; indexesCounter < indexes.size(); indexesCounter++)
     {
       QString name = m_VariableStack[indexes.at(indexesCounter).row()][0];
       QString type = m_VariableStack[indexes.at(indexesCounter).row()][2];
 
       if(type != "DataNode_PointerPtr")
           return NULL;
 
       mitk::DataNode* node;
       itk::SmartPointer<mitk::DataNode> *arg;
 
       PyObject * obj = this->getPyObjectString(&name);
       int i = 0;
       while(swig_types_initial[i] != 0)
       {
         if(swig_types_initial[i] == _swigt__p_itk__SmartPointerTmitk__DataNode_t)
           SWIGTYPE_p_itk__SmartPointerTmitk__DataNode_t = SWIG_TypeRegister(swig_types_initial[i]);
         i++;
       }
       if ((SWIG_ConvertPtr(obj,(void **)(&arg),SWIGTYPE_p_itk__SmartPointerTmitk__DataNode_t,
                            SWIG_POINTER_EXCEPTION | 0)) == -1) return NULL;
 
       if(arg == NULL){
           return NULL;
       }
       try {
           node = (mitk::DataNode *)((itk::SmartPointer<mitk::DataNode > const *)arg)->GetPointer();
       }
       catch(std::exception &_e) {
           {
               std::cout << "Not a DataNode" << std::endl;
           }
       }
 
       long a = reinterpret_cast<long>(node);
 
       if (dataNodeAddresses.size() != 0)
       {
         QTextStream(&dataNodeAddresses) << ",";
       }
       QTextStream(&dataNodeAddresses) << a;
 
       ret->setData("application/x-mitk-datanodes", QByteArray(dataNodeAddresses.toAscii()));
     }
 
     return ret;
-    */
+
 }
+*/
 
 QStringList QmitkPythonVariableStackTableModel::mimeTypes() const
 {
     return QAbstractTableModel::mimeTypes();
     QStringList types;
     types << "application/x-mitk-datanodes";
     types << "application/x-qabstractitemmodeldatalist";
     return types;
 }
 
 Qt::DropActions QmitkPythonVariableStackTableModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
-Qt::DropActions QmitkPythonVariableStackTableModel::supportedDragActions() const
-{
-    return Qt::CopyAction | Qt::MoveAction;
-}
 
 void QmitkPythonVariableStackTableModel::Update()
 {
 //  std::cout << "QmitkPythonVariableStackTableModel::update()" << std::endl;
   this->setVariableStack(this->getAttributeList());
 }
 
 QList<QStringList> QmitkPythonVariableStackTableModel::getAttributeList()
 {
   PyObject* dict = PyImport_GetModuleDict();
   PyObject* object = PyDict_GetItemString(dict, "__main__");
   PyObject* dirMain = PyObject_Dir(object);
   PyObject* tempObject;
   QList<QStringList> variableStack;
 
   if(dirMain)
   {
     QString attr, attrValue, attrType;
     variableStack.clear();
     for(int i = 0; i<PyList_Size(dirMain); i++)
     {
       tempObject = PyList_GetItem(dirMain, i);
       attr = PyString_AsString(tempObject);
       tempObject = PyObject_GetAttrString(object, attr.toLocal8Bit().data());
       attrType = tempObject->ob_type->tp_name;
       if(PyUnicode_Check(tempObject) || PyString_Check(tempObject))
         attrValue = PyString_AsString(tempObject);
       else
         attrValue = "";
       variableStack.push_back(QStringList() << attr << attrValue << attrType);
     }
   }
   return variableStack;
 }
 
 PyObject * QmitkPythonVariableStackTableModel::getPyObject(PyObject * object)
 {
   PyObject* dict = PyImport_GetModuleDict();
   PyObject* main = PyDict_GetItemString(dict, "__main__");
   return PyObject_GetAttr(main, object);
 }
 
 PyObject * QmitkPythonVariableStackTableModel::getPyObjectString(const QString &objectName)
 {
   PyObject* dict = PyImport_GetModuleDict();
   PyObject* main = PyDict_GetItemString(dict, "__main__");
   return PyObject_GetAttrString(main, objectName.toLocal8Bit().data());
 }
diff --git a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.h b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.h
index 276b7b0cdc..346db2f208 100755
--- a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.h
+++ b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonVariableStackTableModel.h
@@ -1,68 +1,68 @@
 /*===================================================================
 
 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 QmitkPythonVariableStackTableModel_h
 #define QmitkPythonVariableStackTableModel_h
 
 #include <QAbstractTableModel>
 #include <QStringList>
 #include <QVariant>
 #include <QModelIndex>
 #include <QModelIndex>
 #include <Python.h>
 #include <itkImage.h>
+#include <mitkDataNode.h>
 
 ///
 /// implements a table model to show the variables of the Python "__main__" dictionary
 /// furthermore implements dragging and dropping of datanodes (conversion from and to python)
 ///
 class QmitkPythonVariableStackTableModel : public QAbstractTableModel
 {
   Q_OBJECT
 
 public:
   QmitkPythonVariableStackTableModel(QObject *parent = 0);
   virtual ~QmitkPythonVariableStackTableModel();
 
   int rowCount(const QModelIndex &parent = QModelIndex()) const;
   int columnCount(const QModelIndex &parent = QModelIndex()) const;
   QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
   Qt::ItemFlags flags( const QModelIndex& index ) const;
   virtual QVariant headerData(int section, Qt::Orientation orientation,
                               int role) const;
   QStringList mimeTypes() const;
 
   void clear();
   void setVariableStack(QList<QStringList>);
   QList<QStringList> getVariableStack();
 
-  QMimeData * mimeData(const QModelIndexList &) const;
   bool dropMimeData ( const QMimeData *, Qt::DropAction, int, int, const QModelIndex & );
   Qt::DropActions supportedDropActions() const;
   Qt::DropActions supportedDragActions() const;
 
 public slots:
   void Update();
 protected:
   QList<QStringList> getAttributeList();
   PyObject* getPyObject(PyObject* object);
   PyObject* getPyObjectString(const QString& objectName);
 
 private:
   QList<QStringList> m_VariableStack;
 };
 
 #endif // QmitkPythonVariableStackTableModel_h
diff --git a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
index 54f34c048f..4bc00f3b04 100644
--- a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
+++ b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.cpp
@@ -1,77 +1,131 @@
 /*===================================================================
 
 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 "QmitkPythonView.h"
 #include <QtGui>
 #include "QmitkCtkPythonShell.h"
 #include "mitkPluginActivator.h"
 #include "QmitkPythonVariableStackTableModel.h"
+#include <mitkIOUtil.h>
+#include <ctkAbstractPythonManager.h>
 
 const std::string QmitkPythonView::VIEW_ID = "org.mitk.views.python";
 
 struct QmitkPythonViewData
 {
     // widget
     QmitkPythonVariableStackTableModel* m_VariableStackTableModel;
     QmitkCtkPythonShell* m_PythonShell;
 };
 
 QmitkPythonView::QmitkPythonView()
     : d( new QmitkPythonViewData )
 {
     d->m_PythonShell = 0;
 }
 
 QmitkPythonView::~QmitkPythonView()
 {
     delete d;
 }
 
+void QmitkPythonView::OnVariableStackDoubleClicked(const QModelIndex &index)
+{
+    QString command;
+    QString tmpFolder = QDir::tempPath();
+
+    QString name = d->m_VariableStackTableModel->getVariableStack().at(index.row())[0];
+    QString fileName = tmpFolder + QDir::separator() + name + ".nrrd";
+
+    MITK_INFO << "Saving temporary file with python itk code " << fileName.toStdString();
+    command.append("import itk\n");
+    command.append( QString( "writer = itk.ImageFileWriter[ %1 ].New()\n").arg( name ) );
+    command.append( QString( "writer.SetFileName( \"%1\" )\n").arg(fileName) );
+    command.append( QString( "writer.SetInput( %1 )\n").arg(name) );
+    command.append("writer.Update()\n");
+    mitk::PluginActivator::GetPythonManager()->executeString(command, ctkAbstractPythonManager::FileInput );
+    d->m_VariableStackTableModel->Update();
+
+    mitk::Image::Pointer mitkImage;
+    try
+    {
+        MITK_INFO << "Loading temporary file " << fileName.toStdString() << " as MITK image";
+        mitkImage = mitk::IOUtil::LoadImage( fileName.toStdString() );
+    }
+    catch(std::exception& e)
+    {
+        MITK_ERROR << e.what();
+    }
+
+    QFile file(fileName);
+    if( file.exists() )
+    {
+        MITK_INFO << "Removing temporary file " << fileName.toStdString();
+        file.remove();
+    }
+
+    if( mitkImage.IsNotNull() )
+    {
+        QString nodeName = name.replace("image_", "");
+        mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode( nodeName.toStdString().c_str() );
+        if( node.IsNull() )
+        {
+            node = mitk::DataNode::New();
+            this->GetDataStorage()->Add(node);
+        }
+
+        node->SetData( mitkImage );
+
+        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+    }
+}
+
 void QmitkPythonView::CreateQtPartControl(QWidget* parent)
 {
     d->m_VariableStackTableModel = new QmitkPythonVariableStackTableModel(parent);
     d->m_VariableStackTableModel->Update();
 
     QTableView* variableStackView = new QTableView;
     variableStackView->setSelectionBehavior( QAbstractItemView::SelectRows );
     variableStackView->setAlternatingRowColors(true);
-    variableStackView->setDragEnabled(true);
+    //variableStackView->setDragEnabled(true);
     variableStackView->setDropIndicatorShown(true);
     variableStackView->setAcceptDrops(true);
     variableStackView->setModel( d->m_VariableStackTableModel );
 
     d->m_PythonShell = new QmitkCtkPythonShell;
     d->m_PythonShell->SetPythonManager( mitk::PluginActivator::GetPythonManager() );
 
     QList<int> sizes;
     sizes << 1 << 3;
     QSplitter* splitter = new QSplitter;
     splitter->addWidget(variableStackView);
     splitter->addWidget(d->m_PythonShell);
     splitter->setStretchFactor ( 0, 1 );
     splitter->setStretchFactor ( 1, 3 );
 
     QGridLayout* layout = new QGridLayout;
     layout->addWidget( splitter, 0, 0 );
     parent->setLayout(layout);
 
     connect( d->m_PythonShell, SIGNAL(newCommandExecuted()), d->m_VariableStackTableModel, SLOT(Update()) );
+    connect( variableStackView, SIGNAL(doubleClicked ( const QModelIndex& )), this, SLOT( OnVariableStackDoubleClicked(const QModelIndex&) ) );
 }
 
 void QmitkPythonView::SetFocus()
 {
     d->m_PythonShell->setFocus();
 }
diff --git a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.h b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.h
index 41b4bee47a..5d781cd98b 100644
--- a/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.h
+++ b/Plugins/org.mitk.gui.qt.python/src/internal/QmitkPythonView.h
@@ -1,64 +1,70 @@
 /*===================================================================
 
 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 QmitkPythonView_H_
 #define QmitkPythonView_H_
 
 /// Qmitk
 #include <QmitkAbstractView.h>
 
 ///
 /// d pointer forward declaration
 ///
 struct QmitkPythonViewData;
 
 ///
 /// \brief New python view (CONSOLE)
 ///
 class QmitkPythonView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID; // = "org.mitk.extapp.defaultperspective"
   ///
   /// \brief Standard ctor.
   ///
   QmitkPythonView();
 
   ///
   /// \brief Standard dtor.
   ///
   virtual ~QmitkPythonView();
 
+  ///
+  /// \brief Standard dtor.
+  ///
+public slots:
+  void OnVariableStackDoubleClicked( const QModelIndex & index );
+
 protected:
 
   ///
   /// \brief Create the view here.
   ///
   virtual void CreateQtPartControl(QWidget* parent);
 
   ///
   /// focus on load image
   ///
   void SetFocus();
 
 private:
   QmitkPythonViewData* d;
 };
 
 #endif /*QmitkPythonView_H_*/