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;
}