diff --git a/Modules/Python/autoload/PythonService/mitkPythonActivator.cpp b/Modules/Python/autoload/PythonService/mitkPythonActivator.cpp
index d58ba5cf27..f14ab932c2 100644
--- a/Modules/Python/autoload/PythonService/mitkPythonActivator.cpp
+++ b/Modules/Python/autoload/PythonService/mitkPythonActivator.cpp
@@ -1,63 +1,63 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkPythonActivator_h
#define mitkPythonActivator_h
// Microservices
+#include "mitkPythonService.h"
#include <usModuleActivator.h>
#include "usModuleContext.h"
-#include "mitkPythonService.h"
#include <usServiceRegistration.h>
namespace mitk
{
///
/// installs the PythonService
/// runs all initial commands (setting env paths etc)
///
class PythonActivator : public us::ModuleActivator
{
public:
void Load(us::ModuleContext* context) override
{
MITK_DEBUG << "PythonActivator::Load";
// Registering PythonService as MicroService
m_PythonService = itk::SmartPointer<mitk::PythonService>(new PythonService());
us::ServiceProperties _PythonServiceProps;
_PythonServiceProps["Name"] = std::string("PythonService");
m_PythonServiceRegistration = context->RegisterService<mitk::IPythonService>(m_PythonService.GetPointer(), _PythonServiceProps);
}
void Unload(us::ModuleContext*) override
{
MITK_DEBUG("PythonActivator") << "PythonActivator::Unload";
MITK_DEBUG("PythonActivator") << "m_PythonService GetReferenceCount " << m_PythonService->GetReferenceCount();
m_PythonServiceRegistration.Unregister();
m_PythonService->Delete();
MITK_DEBUG("PythonActivator") << "m_PythonService GetReferenceCount " << m_PythonService->GetReferenceCount();
}
~PythonActivator() override
{
}
private:
itk::SmartPointer<mitk::PythonService> m_PythonService;
us::ServiceRegistration<PythonService> m_PythonServiceRegistration;
};
}
US_EXPORT_MODULE_ACTIVATOR(mitk::PythonActivator)
#endif
diff --git a/Modules/Python/autoload/PythonService/mitkPythonService.h b/Modules/Python/autoload/PythonService/mitkPythonService.h
index 31338dd8e1..6158d4be84 100644
--- a/Modules/Python/autoload/PythonService/mitkPythonService.h
+++ b/Modules/Python/autoload/PythonService/mitkPythonService.h
@@ -1,107 +1,107 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkPythonService_h
#define mitkPythonService_h
+#include <mitkIPythonService.h>
+#include <mitkSurface.h>
#include <ctkAbstractPythonManager.h>
-#include "mitkIPythonService.h"
#include <itkLightObject.h>
-#include "mitkSurface.h"
namespace mitk
{
///
/// implementation of the IPythonService using ctkabstractpythonmanager
/// \see IPythonService
class PythonService: public itk::LightObject, public mitk::IPythonService
{
public:
///
/// instantiate python manager here
PythonService();
///
/// empty implementation...
~PythonService() override;
///
/// \see IPythonService::Execute()
std::string Execute( const std::string& pythonCommand, int commandType = SINGLE_LINE_COMMAND ) override;
///
/// \see IPythonService::ExecuteScript()
void ExecuteScript(const std::string &pathToPythonScript) override;
///
/// \see IPythonService::PythonErrorOccured()
bool PythonErrorOccured() const override;
///
/// \see IPythonService::GetVariableStack()
std::vector<PythonVariable> GetVariableStack() const override;
///
/// \see IPythonService::DoesVariableExist()
bool DoesVariableExist(const std::string& name) const override;
///
/// \see IPythonService::GetVariable()
std::string GetVariable(const std::string& name) const override;
///
/// \see IPythonService::AddPythonCommandObserver()
void AddPythonCommandObserver( PythonCommandObserver* observer ) override;
///
/// \see IPythonService::RemovePythonCommandObserver()
void RemovePythonCommandObserver( PythonCommandObserver* observer ) override;
///
/// \see IPythonService::NotifyObserver()
void NotifyObserver( const std::string& command ) override;
///
/// \see IPythonService::IsItkPythonWrappingAvailable()
bool IsSimpleItkPythonWrappingAvailable() override;
///
/// \see IPythonService::CopyToPythonAsItkImage()
bool CopyToPythonAsSimpleItkImage( mitk::Image* image, const std::string& varName ) override;
///
/// \see IPythonService::CopyItkImageFromPython()
mitk::Image::Pointer CopySimpleItkImageFromPython( const std::string& varName ) override;
///
/// \see IPythonService::IsOpenCvPythonWrappingAvailable()
bool IsOpenCvPythonWrappingAvailable() override;
///
/// \see IPythonService::CopyToPythonAsCvImage()
bool CopyToPythonAsCvImage( mitk::Image* image, const std::string& varName ) override;
///
/// \see IPythonService::CopyCvImageFromPython()
mitk::Image::Pointer CopyCvImageFromPython( const std::string& varName ) override;
///
/// \see IPythonService::IsVtkPythonWrappingAvailable()
bool IsVtkPythonWrappingAvailable() override;
///
/// \see IPythonService::CopyToPythonAsVtkPolyData()
bool CopyToPythonAsVtkPolyData( mitk::Surface* surface, const std::string& varName ) override;
///
/// \see IPythonService::CopyVtkPolyDataFromPython()
mitk::Surface::Pointer CopyVtkPolyDataFromPython( const std::string& varName ) override;
///
/// \return the ctk abstract python manager instance
ctkAbstractPythonManager* GetPythonManager() override;
void AddRelativeSearchDirs(std::vector< std::string > dirs) override;
void AddAbsoluteSearchDirs(std::vector< std::string > dirs) override;
protected:
private:
QList<PythonCommandObserver*> m_Observer;
ctkAbstractPythonManager m_PythonManager;
bool m_ItkWrappingAvailable;
bool m_OpenCVWrappingAvailable;
bool m_VtkWrappingAvailable;
bool m_ErrorOccured;
};
}
#endif
diff --git a/Modules/Python/mitkIPythonService.h b/Modules/Python/mitkIPythonService.h
index eb9c4d1dad..e53457d24a 100644
--- a/Modules/Python/mitkIPythonService.h
+++ b/Modules/Python/mitkIPythonService.h
@@ -1,153 +1,155 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkIPythonService_h
#define mitkIPythonService_h
// mitk
+#include <mitkImage.h>
+#include <mitkSurface.h>
#include <MitkPythonExports.h>
-#include "mitkImage.h"
+
//for microservices
#include <mitkServiceInterface.h>
-#include "mitkSurface.h"
+
#include <vector>
class ctkAbstractPythonManager;
namespace mitk
{
///
/// describes a python variable (data container)
/// \see IPythonService::GetVariableStack()
///
struct PythonVariable
{
std::string m_Name;
std::string m_Type;
std::string m_Value;
};
///
/// a PythonCommandObserver gets informed as soon as a python command was issued
/// \see IPythonService::AddPythonCommandObserver()
///
class PythonCommandObserver
{
public:
virtual void CommandExecuted(const std::string& 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 MITKPYTHON_EXPORT IPythonService
{
public:
///
/// Constant representing a single line command
/// \see IPythonService::Execute()
static const int SINGLE_LINE_COMMAND = 0;
///
/// Constant representing a command in which the commands are seperated by new lines, i.e. "\\n"
/// \see IPythonService::Execute()
static const int MULTI_LINE_COMMAND = 1;
///
/// Constant representing a single line command x which is run as "eval(x)"
/// \see IPythonService::Execute()
static const int EVAL_COMMAND = 2;
///
/// Executes a python command.
/// \return A variant containing the return value as string of the python code (if any)
virtual std::string Execute( const std::string& pythonCommand, int commandType = SINGLE_LINE_COMMAND ) = 0;
///
/// Executes a python script.
virtual void ExecuteScript( const std::string& pathToPythonScript ) = 0;
///
/// \return true if the last call to Execute...() resulted in an error, false otherwise
virtual bool PythonErrorOccured() const = 0;
///
/// \return The list of variables in the __main__ namespace
virtual std::vector<PythonVariable> GetVariableStack() const = 0;
///
/// \return true if a variable with this name is defined in the __main__ namespace, false otherwise
virtual bool DoesVariableExist(const std::string& name) const = 0;
///
/// \return value of variable with this name as string, empty string if variable does not exist
virtual std::string GetVariable(const std::string& name) const = 0;
///
/// adds a command observer which is informed after a command was issued with "Execute"
virtual void AddPythonCommandObserver( PythonCommandObserver* observer ) = 0;
///
/// removes a specific command observer
virtual void RemovePythonCommandObserver( PythonCommandObserver* observer ) = 0;
///
/// notify all observer. this should only be used if it can be garantueed that the
/// current python interpreter instance got another command from anywhere else
/// the the Execute() method of this service, e.g. the shell widget uses this function
/// since it does not use Execute()
virtual void NotifyObserver( const std::string& command ) = 0;
///
/// \return true, if itk wrapping is available, false otherwise
virtual bool IsSimpleItkPythonWrappingAvailable() = 0;
///
/// copies an mitk image as itk image into the python interpreter process
/// the image will be available as "varName" in python if everythin worked
/// \return true if image was copied, else false
virtual bool CopyToPythonAsSimpleItkImage( mitk::Image* image, const std::string& varName ) = 0;
///
/// copies an itk image from the python process that is named "varName"
/// \return the image or 0 if copying was not possible
virtual mitk::Image::Pointer CopySimpleItkImageFromPython( const std::string& varName ) = 0;
///
/// \return true, if OpenCv wrapping is available, false otherwise
virtual bool IsOpenCvPythonWrappingAvailable() = 0;
///
/// \see CopyToPythonAsItkImage()
virtual bool CopyToPythonAsCvImage( mitk::Image* image, const std::string& varName ) = 0;
///
/// \see CopyCvImageFromPython()
virtual mitk::Image::Pointer CopyCvImageFromPython( const std::string& varName ) = 0;
///
/// \return true, if vtk wrapping is available, false otherwise
virtual bool IsVtkPythonWrappingAvailable() = 0;
///
/// \see CopyToPythonAsItkImage()
virtual bool CopyToPythonAsVtkPolyData( mitk::Surface* surface, const std::string& varName ) = 0;
///
/// \see CopyCvImageFromPython()
virtual mitk::Surface::Pointer CopyVtkPolyDataFromPython( const std::string& varName ) = 0;
/// \return the ctk abstract python manager instance
virtual ctkAbstractPythonManager* GetPythonManager() = 0;
///
/// nothing to do here
virtual ~IPythonService(); // leer in mitkIPythonService.cpp implementieren
// force us module loading by linking
static std::string ForceLoadModule();
virtual void AddRelativeSearchDirs(std::vector< std::string > dirs) = 0;
virtual void AddAbsoluteSearchDirs(std::vector< std::string > dirs) = 0;
};
}
MITK_DECLARE_SERVICE_INTERFACE(mitk::IPythonService, "org.mitk.services.IPythonService")
#endif
diff --git a/Modules/QtPython/QmitkCtkPythonShell.cpp b/Modules/QtPython/QmitkCtkPythonShell.cpp
index ebdbbf36d8..c557fa1eac 100644
--- a/Modules/QtPython/QmitkCtkPythonShell.cpp
+++ b/Modules/QtPython/QmitkCtkPythonShell.cpp
@@ -1,94 +1,94 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkCtkPythonShell.h"
+#include <mitkIPythonService.h>
#include <ctkAbstractPythonManager.h>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QMimeData>
#include <QUrl>
-#include "mitkIPythonService.h"
#include <usModuleContext.h>
#include <usServiceReference.h>
#include <usGetModuleContext.h>
struct QmitkCtkPythonShellData
{
mitk::IPythonService* m_PythonService;
us::ServiceReference<mitk::IPythonService> m_PythonServiceRef;
};
QmitkCtkPythonShell::QmitkCtkPythonShell(QWidget* parent)
: ctkPythonConsole(parent), d( new QmitkCtkPythonShellData )
{
this->setWelcomeTextColor(Qt::green);
this->setPromptColor(Qt::gray);
this->setStdinTextColor(Qt::white);
this->setCommandTextColor(Qt::white);
this->setOutputTextColor(Qt::white);
MITK_DEBUG("QmitkCtkPythonShell") << "retrieving IPythonService";
us::ModuleContext* context = us::GetModuleContext();
d->m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
d->m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(d->m_PythonServiceRef) );
MITK_DEBUG("QmitkCtkPythonShell") << "checking IPythonService";
Q_ASSERT( d->m_PythonService );
MITK_DEBUG("QmitkCtkPythonShell") << "initialize m_PythonService";
this->initialize( d->m_PythonService->GetPythonManager() );
MITK_DEBUG("QmitkCtkPythonShell") << "m_PythonService initialized";
mitk::IPythonService::ForceLoadModule();
}
QmitkCtkPythonShell::~QmitkCtkPythonShell()
{
us::ModuleContext* context = us::GetModuleContext();
context->UngetService( d->m_PythonServiceRef );
delete d;
}
void QmitkCtkPythonShell::dragEnterEvent(QDragEnterEvent *event)
{
event->accept();
}
void QmitkCtkPythonShell::dropEvent(QDropEvent *event)
{
QList<QUrl> urls = event->mimeData()->urls();
for(int i = 0; i < urls.size(); i++)
{
d->m_PythonService->Execute( urls[i].toString().toStdString(), mitk::IPythonService::SINGLE_LINE_COMMAND );
}
}
bool QmitkCtkPythonShell::canInsertFromMimeData(const QMimeData *) const
{
return true;
}
void QmitkCtkPythonShell::executeCommand(const QString& command)
{
MITK_DEBUG("QmitkCtkPythonShell") << "executing command " << command.toStdString();
d->m_PythonService->Execute(command.toStdString(),mitk::IPythonService::MULTI_LINE_COMMAND);
d->m_PythonService->NotifyObserver(command.toStdString());
}
void QmitkCtkPythonShell::Paste(const QString &command)
{
if( this->isVisible() )
{
this->exec( command );
//this->executeCommand( command );
}
}