diff --git a/Modules/Python/QmitkPythonVariableStackTableModel.cpp b/Modules/Python/QmitkPythonVariableStackTableModel.cpp
index 650580a304..352678ba58 100755
--- a/Modules/Python/QmitkPythonVariableStackTableModel.cpp
+++ b/Modules/Python/QmitkPythonVariableStackTableModel.cpp
@@ -1,185 +1,190 @@
 /*===================================================================
 
 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 <mitkModuleContext.h>
 #include <usServiceReference.h>
 #include <mitkDataNode.h>
 #include <mitkGetModuleContext.h>
 #include <QStringList>
 
 const QString QmitkPythonVariableStackTableModel::m_PythonImagesDictName("images");
 
 QmitkPythonVariableStackTableModel::QmitkPythonVariableStackTableModel(QObject *parent)
     :QAbstractTableModel(parent)
 {
     mitk::ModuleContext* context = mitk::GetModuleContext();
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::IPythonService>();
     m_PythonService = context->GetService<mitk::IPythonService>(serviceRef);
 }
 
 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";
+        MITK_DEBUG("QmitkPythonVariableStackTableModel") << "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());
 
-          m_PythonService->Execute(CreateDictionaryCommandIfNecessary(), mitk::IPythonService::MULTI_LINE_COMMAND );
+          QString command = CreateDictionaryCommandIfNecessary();
+
+          m_PythonService->Execute(command, mitk::IPythonService::MULTI_LINE_COMMAND );
 
           QString varName = GetDictionaryVarNameForNodeName(node->GetName());
           MITK_DEBUG("varName") << "varName" << varName;
-          m_PythonService->CopyToPythonAsItkImage( mitkImage, varName );
+          //m_PythonService->CopyToPythonAsItkImage( mitkImage, varName );
         }
     }
     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)
         {
             mitk::PythonVariable item = m_VariableStack.at(index.row());
             if(index.column() == 0)
                 return item.m_Name;
             if(index.column() == 1)
                 return item.m_Value;
             if(index.column() == 2)
                 return item.m_Type;
         }
     }
     return QVariant();
 }
 
 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;
 }
 
 void QmitkPythonVariableStackTableModel::CommandExecuted(const QString &pythonCommand)
 {
     m_VariableStack = m_PythonService->GetVariableStack();
     QAbstractTableModel::reset();
 }
 
 QList<mitk::PythonVariable> QmitkPythonVariableStackTableModel::GetVariableStack() const
 {
     return m_VariableStack;
 }
 
 
 QString QmitkPythonVariableStackTableModel::CreateDictionaryCommandIfNecessary()
 {
+    MITK_DEBUG("QmitkPythonVariableStackTableModel") << "CreateDictionaryCommandIfNecessary()";
+    MITK_DEBUG("QmitkPythonVariableStackTableModel") << "m_PythonImagesDictName = " << m_PythonImagesDictName.toStdString();
+
     QString command;
     command.append( QString("try:\n") );
     command.append( QString("  %1" ) .arg( m_PythonImagesDictName ) );
     command.append( QString("except NameError:\n") );
     command.append( QString("  %1 = {}\n") .arg( m_PythonImagesDictName ) );
     return command;
 }
 
 QString QmitkPythonVariableStackTableModel::GetDictionaryVarNameForNodeName(const std::string &nodeName)
 {
     QString varName = QString("%1['%2']") .arg( m_PythonImagesDictName ) .arg( QString::fromStdString( nodeName ) );
     return varName;
 }
 
 std::string QmitkPythonVariableStackTableModel::GetNodeNameForDictionaryVarName(const QString &varName)
 {
     QString qNodeName = varName;
     qNodeName = qNodeName.replace( m_PythonImagesDictName+"['", "" );
     qNodeName = qNodeName.replace("']", "");
     MITK_DEBUG("QmitkPythonVariableStackTableModel") << "qNodeName " << qNodeName.toStdString();
     return qNodeName.toStdString();
 }
diff --git a/Modules/Python/mitkIPythonService.h b/Modules/Python/mitkIPythonService.h
index e0392eb813..7976e7e0d6 100644
--- a/Modules/Python/mitkIPythonService.h
+++ b/Modules/Python/mitkIPythonService.h
@@ -1,79 +1,79 @@
 /*===================================================================
 
 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 mitkIPythonService_h
 #define mitkIPythonService_h
 
 // mitk
 #include "mitkPythonExports.h"
 #include "mitkImage.h"
 //for microservices
 #include <usServiceInterface.h>
 // Qt
 #include <QString>
 #include <QVariant>
 #include <QList>
 
 namespace mitk
 {
     ///
     /// describes a python variable (data container)
     /// \see IPythonService::GetVariableStack()
     ///
     struct PythonVariable
     {
       QString m_Name;
       QString m_Type;
       QString m_Value;
     };
 
     ///
     /// a PythonCommandObserver gets informed as soon as a python command was issued
     /// \see IPythonService::AddPythonCommandObserver()
     ///
     class PythonCommandObserver
     {
     public:
       virtual void CommandExecuted(const QString& pythonCommand) = 0;
     };
 
     ///
     /// The central service for issuing Python Code
     /// The class also enables to transfer mitk images to python as itk::Image and vice versa
     /// \see IPythonService::GetVariableStack()
     ///
     class MITK_PYTHON_EXPORT IPythonService
     {
     public:
         static const int SINGLE_LINE_COMMAND = 0;
         static const int MULTI_LINE_COMMAND = 1;
         static const int EVAL_COMMAND = 2;
 
         virtual ~IPythonService(); // leer in mitkIPythonService.cpp implementieren
         virtual QVariant Execute( const QString& pythonCommand, int commandType = SINGLE_LINE_COMMAND ) = 0;
         virtual QList<PythonVariable> GetVariableStack() const = 0;
 
         virtual void AddPythonCommandObserver( PythonCommandObserver* observer ) = 0;
         virtual void RemovePythonCommandObserver( PythonCommandObserver* observer ) = 0;
         virtual void NotifyObserver( const QString& command ) = 0;
 
         virtual bool CopyToPythonAsItkImage( mitk::Image* image, const QString& varName ) = 0;
         virtual mitk::Image::Pointer CopyItkImageFromPython( const QString& varName ) = 0;
     };
 }
 
-//US_DECLARE_SERVICE_INTERFACE(mitk::IPythonService, "org.mitk.services.IPythonService")
+US_DECLARE_SERVICE_INTERFACE(mitk::IPythonService, "org.mitk.services.IPythonService")
 
 #endif
diff --git a/Modules/Python/mitkPythonActivator.cpp b/Modules/Python/mitkPythonActivator.cpp
index 123feb1ffb..032b26a316 100644
--- a/Modules/Python/mitkPythonActivator.cpp
+++ b/Modules/Python/mitkPythonActivator.cpp
@@ -1,79 +1,79 @@
 /*===================================================================
 
 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 mitkPythonActivator_h
 #define mitkPythonActivator_h
 
 // Microservices
 #include <usModuleActivator.h>
 #include "mitkModuleContext.h"
 #include "mitkPythonService.h"
 #include <usServiceRegistration.h>
 #include "PythonPath.h"
 
 namespace mitk
 {
     ///
     /// installs the PythonService
     /// runs all initial commands (setting env paths etc)
     ///
     class PythonActivator : public mitk::ModuleActivator
     {
     public:
 
         void Load(mitk::ModuleContext* context)
         {
             // Registering PythonService as MicroService
             m_PythonService = itk::SmartPointer<mitk::PythonService>(new PythonService());
 
             ServiceProperties _PythonServiceProps;
             _PythonServiceProps["Name"] = std::string("PythonService");
 
             context->RegisterService<mitk::IPythonService>(m_PythonService, _PythonServiceProps);
 
             MITK_DEBUG << "registering python paths";
 
             QString itkLibDirs(PYTHONPATH_ITK_LIBRARY_DIRS);
             MITK_DEBUG << "itkLibDirs" << itkLibDirs.toStdString();
 
             QString itkWrapItkDir(PYTHONPATH_WRAP_ITK_DIR);
             MITK_DEBUG << "itkWrapItkDir" << itkWrapItkDir.toStdString();
 
             QString basecommand = "sys.path.append('%1');";
             QString pythonCommand;
             pythonCommand = basecommand.arg(itkLibDirs);
             MITK_DEBUG << "issuing command " << pythonCommand.toStdString();
             m_PythonService->Execute(pythonCommand, mitk::IPythonService::SINGLE_LINE_COMMAND );
 
             pythonCommand = basecommand.arg(itkWrapItkDir);
             MITK_DEBUG << "issuing command " << pythonCommand.toStdString();
             m_PythonService->Execute(pythonCommand, mitk::IPythonService::SINGLE_LINE_COMMAND );
         }
 
         void Unload(mitk::ModuleContext* )
         {
         }
 
         ~PythonActivator()
         {
         }
 
     private:
         itk::SmartPointer<mitk::PythonService> m_PythonService;
     };
 }
 
-//US_EXPORT_MODULE_ACTIVATOR(mitkPython, mitk::PythonActivator)
+US_EXPORT_MODULE_ACTIVATOR(mitkPython, mitk::PythonActivator)
 #endif
diff --git a/Modules/Python/mitkPythonService.cpp b/Modules/Python/mitkPythonService.cpp
index 18f5f0423d..a167b03030 100644
--- a/Modules/Python/mitkPythonService.cpp
+++ b/Modules/Python/mitkPythonService.cpp
@@ -1,192 +1,197 @@
 /*===================================================================
 
 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 "mitkPythonService.h"
 #include <Python.h>
 #include <mitkIOUtil.h>
 #include <QFile>
 #include <QDir>
 
 const QString mitk::PythonService::m_TmpImageName("temp_mitk_image");
 
 mitk::PythonService::PythonService()
 {
     m_PythonManager.initialize();
 }
 
 mitk::PythonService::~PythonService()
 {
 }
 
 QVariant mitk::PythonService::Execute(const QString &pythonCommand, int commandType)
 {
+    {
+        MITK_DEBUG("mitk::PythonService") << "pythonCommand = " << pythonCommand.toStdString();
+        MITK_DEBUG("mitk::PythonService") << "commandType = " << commandType;
+    }
+
     QVariant result;
     bool commandIssued = true;
 
     if(commandType == IPythonService::SINGLE_LINE_COMMAND )
         result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::SingleInput );
     else if(commandType == IPythonService::MULTI_LINE_COMMAND )
         result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::FileInput );
     else if(commandType == IPythonService::EVAL_COMMAND )
         result = m_PythonManager.executeString(pythonCommand, ctkAbstractPythonManager::EvalInput );
     else
         commandIssued = false;
 
     if(commandIssued)
         this->NotifyObserver(pythonCommand);
 
     return result;
 }
 
 QList<mitk::PythonVariable> mitk::PythonService::GetVariableStack() const
 {
     QList<mitk::PythonVariable> list;
 
     PyObject* dict = PyImport_GetModuleDict();
     PyObject* object = PyDict_GetItemString(dict, "__main__");
     PyObject* dirMain = PyObject_Dir(object);
     PyObject* tempObject;
 
     if(dirMain)
     {
       QString attr, attrValue, attrType;
 
       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 = "";
         mitk::PythonVariable var;
         var.m_Name = attr;
         var.m_Value = attrValue;
         var.m_Type = attrType;
         list.append(var);
       }
     }
 
     return list;
 }
 
 void mitk::PythonService::AddPythonCommandObserver(mitk::PythonCommandObserver *observer)
 {
     if(m_Observer.contains(observer))
         m_Observer.append(observer);
 }
 
 void mitk::PythonService::RemovePythonCommandObserver(mitk::PythonCommandObserver *observer)
 {
     m_Observer.removeOne(observer);
 }
 
 void mitk::PythonService::NotifyObserver(const QString &command)
 {
     foreach(mitk::PythonCommandObserver* observer, m_Observer)
     {
         observer->CommandExecuted(command);
     }
 }
 
 QString mitk::PythonService::GetTempImageName(const QString& ext) const
 {
     QString tmpFolder = QDir::tempPath();
     QString fileName = tmpFolder + QDir::separator() + m_TmpImageName + ext;
     return fileName;
 }
 
 bool mitk::PythonService::CopyToPythonAsItkImage(mitk::Image *image, const QString &varName)
 {
     // save image
     QString fileName = this->GetTempImageName( QString::fromStdString(mitk::IOUtil::DEFAULTIMAGEEXTENSION) );
 
     MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
     if( !mitk::IOUtil::SaveImage(image, fileName.toStdString()) )
     {
         MITK_ERROR << "Temporary file could not be created.";
     }
     else
     {
         // TODO CORRECT TYPE SETUP, MAKE MITK_DEBUG("PythonService") MITK_DEBUG("PythonService")
         int dim = 3;
         QString type = "US";
         QString command;
 
         command.append( QString("import itk\n") );
         command.append( QString("imageType = itk.Image[%1, %2]\n") .arg( type ).arg( dim ) );
 
         command.append( QString("readerType = itk.ImageFileReader[imageType]\n") );
         command.append( QString("reader = readerType.New()\n") );
         command.append( QString("reader.SetFileName( \"%1\" )\n") .arg(fileName) );
         command.append( QString("reader.Update()\n") );
         command.append( QString("%1 = reader.GetOutput()\n").arg( varName ) );
 
         MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
         this->Execute(command, IPythonService::MULTI_LINE_COMMAND );
 
         QFile file(fileName);
         MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
         file.remove();
         return true;
     }
 
     return false;
 }
 
 mitk::Image::Pointer mitk::PythonService::CopyItkImageFromPython(const QString &varName)
 {
     mitk::Image::Pointer mitkImage;
     QString command;
     QString fileName = GetTempImageName( QString::fromStdString( mitk::IOUtil::DEFAULTIMAGEEXTENSION ) );
 
     MITK_DEBUG("PythonService") << "Saving temporary file with python itk code " << fileName.toStdString();
     command.append( QString("import itk\n") );
 
     command.append( QString( "writer = itk.ImageFileWriter[ %1 ].New()\n").arg( varName ) );
     command.append( QString( "writer.SetFileName( \"%1\" )\n").arg(fileName) );
     command.append( QString( "writer.SetInput( %1 )\n").arg(varName) );
     command.append( QString( "writer.Update()\n" ) );
 
     MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
     this->Execute(command, IPythonService::MULTI_LINE_COMMAND );
 
     try
     {
         MITK_DEBUG("PythonService") << "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_DEBUG("PythonService") << "Removing temporary file " << fileName.toStdString();
         file.remove();
     }
 
     return mitkImage;
 }
 
 ctkAbstractPythonManager *mitk::PythonService::GetPythonManager()
 {
     return &m_PythonManager;
 }