std::string mitk::PythonService::Execute(const std::string &stdpythonCommand, int commandType)
{
QString pythonCommand = QString::fromStdString(stdpythonCommand);
{
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.toStdString());
m_ErrorOccured = PythonQt::self()->hadError();
}
return result.toString().toStdString();
}
mitk::Image::Pointer mitk::PythonService::CopyCvImageFromPython( const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
mitk::Image::Pointer mitkImage;
QString command;
QString fileName = GetTempDataFileName( ".bmp" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "run python command to save image with opencv to " << fileName.toStdString();
command.append( QString( "cv2.imwrite(\"%1\", %2)\n").arg( fileName ).arg( varName ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), 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;
}
bool mitk::PythonService::CopyToPythonAsCvImage( mitk::Image* image, const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
bool convert = false;
if(image->GetDimension() != 2)
{
MITK_ERROR << "Only 2D images allowed for OpenCV images";
return convert;
}
// try to save mitk image
QString fileName = this->GetTempDataFileName( ".bmp" );
fileName = QDir::fromNativeSeparators( fileName );
MITK_DEBUG("PythonService") << "Saving temporary file " << fileName.toStdString();
if( !mitk::IOUtil::SaveImage(image, fileName.toStdString()) )
{
MITK_ERROR << "Temporary file " << fileName.toStdString() << " could not be created.";
return convert;
}
QString command;
command.append( QString("%1 = cv2.imread(\"%2\")\n") .arg( varName ).arg( fileName ) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
MITK_DEBUG("PythonService") << "Removing file " << fileName.toStdString();
QFile file(fileName);
file.remove();
convert = true;
return convert;
}
mitk::Image::Pointer mitk::PythonService::CopyCvImageFromPython( const std::string& stdvarName )
{
// access python module
PyObject *pyMod = PyImport_AddModule((char*)"__main__");
// global dictionarry
PyObject *pyDict = PyModule_GetDict(pyMod);
mitk::Image::Pointer mitkImage = mitk::Image::New();
QString command;
QString varName = QString::fromStdString( stdvarName );
command.append( QString("import numpy as np\n"));
command.append( QString("%1_dtype=%1.dtype.name\n").arg(varName) );
command.append( QString("%1_shape=np.asarray(%1.shape)\n").arg(varName) );
command.append( QString("%1_np_array=%1[:,...,::-1]\n").arg(varName));
command.append( QString("%1_np_array=np.reshape(%1_np_array,%1.shape[0] * %1.shape[1] * %1.shape[2])").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
PyObject* py_dtype = PyDict_GetItemString(pyDict,QString("%1_dtype").arg(varName).toStdString().c_str() );
std::string dtype = PyString_AsString(py_dtype);
PyArrayObject* py_data = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_np_array").arg(varName).toStdString().c_str() );
PyArrayObject* shape = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_shape").arg(varName).toStdString().c_str() );
size_t* d = reinterpret_cast<size_t*>(PyArray_DATA(shape));
unsigned int dimensions[3];
dimensions[0] = d[1];
dimensions[1] = d[0];
dimensions[2] = d[2];
unsigned int nr_dimensions = 2;
// get number of components
unsigned int nr_Components = (unsigned int) d[2];
mitk::PixelType pixelType = DeterminePixelType(dtype, nr_Components, nr_dimensions);
mitkImage->Initialize(pixelType, nr_dimensions, dimensions);
//mitkImage->SetChannel(py_data->data);
{
mitk::ImageWriteAccessor ra(mitkImage);
char* data = (char*)(ra.GetData());
memcpy(data, PyArray_DATA(py_data), dimensions[0] * dimensions[1] * pixelType.GetSize());
}
command.clear();
command.append( QString("del %1_shape\n").arg(varName) );
command.append( QString("del %1_dtype\n").arg(varName) );
command.append( QString("del %1_np_array").arg(varName));
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
return mitkImage;
}
void QmitkPythonVariableStackTableView::OnVariableStackDoubleClicked(const QModelIndex &index)
{
if( m_DataStorage.IsNull() || m_PythonService == 0 )
{
MITK_ERROR << "QmitkPythonVariableStackTableView not configured correctly. Quit";
return;
}
int row = index.row();
std::vector<mitk::PythonVariable> variableStack = m_TableModel->GetVariableStack();
{
MITK_DEBUG("QmitkPythonVariableStackTableView") << "row " << row;
MITK_DEBUG("QmitkPythonVariableStackTableView") << "variableStack.size(): " << variableStack.size();
}
QString varName = QString::fromStdString( variableStack.at(row).m_Name );
QString type = QString::fromStdString( variableStack.at(row).m_Type );
QString value = QString::fromStdString( variableStack.at(row).m_Value );
{
MITK_DEBUG("QmitkPythonVariableStackTableView") << "varName: " << varName.toStdString();
MITK_DEBUG("QmitkPythonVariableStackTableView") << "type: " << type.toStdString();
}
mitk::Image::Pointer mitkImage;
mitk::Surface::Pointer mitkSurface;
if( type.startsWith("itkImage") )
{
mitkImage = m_PythonService->CopyItkImageFromPython(varName.toStdString());
}
else if( type.startsWith("numpy.ndarray") )
{
mitkImage = m_PythonService->CopyCvImageFromPython(varName.toStdString());
}
else if( value.startsWith("(vtkPolyData)") )
{
mitkSurface = m_PythonService->CopyVtkPolyDataFromPython(varName.toStdString());
}
std::string nodeName = varName.toStdString();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetName ( nodeName );
if( mitkImage.IsNotNull() )
{
node->SetData( mitkImage );
}
else if( mitkSurface.IsNotNull() )
{
node->SetData( mitkSurface );
}
m_DataStorage->Add(node);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void Unload(us::ModuleContext* context)
{
if( m_PersistenceService.IsNull() )
return;
MITK_DEBUG("PersistenceActivator") << "PersistenceActivator::Unload";
MITK_DEBUG("PersistenceActivator") << "m_PersistenceService GetReferenceCount " << m_PersistenceService->GetReferenceCount();
m_PersistenceServiceRegistration.Unregister();
m_PersistenceService->Unitialize();
m_PersistenceService->Delete();
}
bool mitk::PersistenceService::RestorePropertyListsFromPersistentDataNodes( const DataStorage* storage )
{
this->Initialize();
bool oneFound = false;
DataStorage::SetOfObjects::ConstPointer allNodes = storage->GetAll();
for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin();
sourceIter != allNodes->end();
++sourceIter )
{
mitk::DataNode* node = *sourceIter;
bool isPersistenceNode = false;
//node->GetBoolProperty( PERSISTENCE_PROPERTY_NAME.c_str(), isPersistenceNode ); //see bug 17729
node->GetBoolProperty( GetPersistencePropertyName().c_str(), isPersistenceNode );
if( isPersistenceNode )
{
oneFound = true;
MITK_DEBUG("mitk::PersistenceService") << "isPersistenceNode was true";
std::string name = node->GetName();
bool existed = false;
mitk::PropertyList::Pointer propList = this->GetPropertyList( name, &existed );
if( existed )
{
MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
while( it != m_PropertyListReplacedObserver.end() )
{
(*it)->BeforePropertyListReplaced( name, propList );
++it;
}
} // if( existed )
MITK_DEBUG("mitk::PersistenceService") << "replacing values";
this->ClonePropertyList( node->GetPropertyList(), propList );
if( existed )
{
MITK_DEBUG("mitk::PersistenceService") << "calling replace observer before replacing values";
std::set<PropertyListReplacedObserver*>::iterator it = m_PropertyListReplacedObserver.begin();
while( it != m_PropertyListReplacedObserver.end() )
{
(*it)->AfterPropertyListReplaced( name, propList );
++it;
}
} // if( existed )
} // if( isPersistenceNode )
} // for ( mitk::DataStorage::SetOfObjects::const_iterator sourceIter = allNodes->begin(); ...
return oneFound;
}
void QmitkPythonSnippets::SaveStringMap(const QString &filename, const QmitkPythonSnippets::QStringMap &) const
{
MITK_DEBUG("QmitkPythonSnippets") << "saving to xml file " << filename.toStdString();
if( filename.isEmpty() )
{
MITK_WARN("QmitkPythonSnippets") << "empty auto save file path given. quit.";
return;
}
QFile file(filename);
file.open(QIODevice::WriteOnly);
if( !file.isOpen() )
{
MITK_WARN("QmitkPythonSnippets") << "could not open file " << filename.toStdString() << " for writing";
return;
}
QXmlStreamWriter xmlWriter(&file);
xmlWriter.setAutoFormatting(true);
xmlWriter.writeStartDocument();
xmlWriter.writeStartElement(SNIPPETS_ROOT_XML_ELEMENT_NAME);
QStringMap::const_iterator it = d->m_Snippets.begin();
while( it != d->m_Snippets.end() )
{
{
MITK_DEBUG("QmitkPythonSnippets") << "SNIPPETS_XML_ELEMENT_NAME " << SNIPPETS_XML_ELEMENT_NAME.toStdString();
MITK_DEBUG("QmitkPythonSnippets") << "writing item " << it.key().toStdString();
}
xmlWriter.writeStartElement(SNIPPETS_XML_ELEMENT_NAME);
xmlWriter.writeAttribute( "key", it.key() );
xmlWriter.writeAttribute( "value", it.value() );
xmlWriter.writeEndElement();
++it;
}
xmlWriter.writeEndDocument();
if( file.isOpen() )
file.close();
{
MITK_DEBUG("QmitkPythonSnippets") << "SaveStringMap successful ";
}
}
void mitk::IGTLServer::Send()
{
igtl::MessageBase::Pointer curMessage;
//get the latest message from the queue
curMessage = this->m_SendQueue->PullMessage();
// there is no message => return
if (curMessage.IsNull())
return;
AddTrackingMeasurements(4, curMessage, 0);
//the server can be connected with several clients, therefore it has to check
//all registered clients
//sending a message to all registered clients might not be the best solution,
//it could be better to store the client together with the requested type. Then
//the data would be send to the appropriate client and to noone else.
//(I know it is no excuse but PLUS is doing exactly the same, they broadcast
//everything)
m_SentListMutex->Lock();
SocketListIteratorType it;
auto it_end =
this->m_RegisteredClients.end();
for (it = this->m_RegisteredClients.begin(); it != it_end; ++it)
{
//maybe there should be a check here if the current socket is still active
this->SendMessagePrivate(curMessage.GetPointer(), *it);
MITK_DEBUG("IGTLServer") << "Sent IGTL Message";
}
m_SentListMutex->Unlock();
}
QmitkCtkPythonShell::QmitkCtkPythonShell(QWidget* parent)
: ctkPythonConsole(parent), d( new QmitkCtkPythonShellData )
{
MITK_DEBUG("QmitkCtkPythonShell") << "retrieving IPythonService";
mitk::ModuleContext* context = mitk::GetModuleContext();
d->m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
d->m_PythonService = dynamic_cast<mitk::PythonService*> ( 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";
}
void mitk::PersistenceService::Initialize()
{
if (m_Initialized || m_InInitialized)
return;
m_InInitialized = true;
m_PropertyListsXmlFileReaderAndWriter = PropertyListsXmlFileReaderAndWriter::New();
// Load Default File in any case
this->Load();
// std::string id = mitk::PersistenceService::PERSISTENCE_PROPERTYLIST_NAME; //see bug 17729
std::string id = GetPersistencePropertyListName();
mitk::PropertyList::Pointer propList = this->GetPropertyList(id);
bool autoLoadAndSave = true;
propList->GetBoolProperty("m_AutoLoadAndSave", autoLoadAndSave);
if (autoLoadAndSave == false)
{
MITK_DEBUG("mitk::PersistenceService") << "autoloading was not wished. clearing data we got so far.";
this->SetAutoLoadAndSave(false);
this->Clear();
}
m_InInitialized = false;
m_Initialized = true;
}
void mitk::PythonService::NotifyObserver(const std::string &command)
{
MITK_DEBUG("mitk::PythonService") << "number of observer " << m_Observer.size();
for( int i=0; i< m_Observer.size(); ++i )
{
m_Observer.at(i)->CommandExecuted(command);
}
}
void QmitkPythonSnippets::on_Name_currentIndexChanged(int i)
{
bool validSelection = i >= 0 ;
d->m_PasteSnippet->setEnabled(validSelection);
d->m_RemoveSnippet->setEnabled(validSelection);
d->m_RenameSnippet->setEnabled(validSelection);
d->m_Content->setEnabled(validSelection);
d->m_SaveSnippets->setEnabled(validSelection);
if( validSelection )
{
QString name = d->m_Name->currentText();
MITK_DEBUG("QmitkPythonSnippets") << "selected snippet " << name.toStdString();
d->m_Content->setText( d->m_Snippets[name] );
MITK_DEBUG("QmitkPythonSnippets") << "selected snippet content " << d->m_Snippets[name].toStdString();
}
}
mitk::PythonService::~PythonService()
{
MITK_DEBUG("mitk::PythonService") << "destructing PythonService";
#ifdef USE_MITK_BUILTIN_PYTHON
if(pHome)
delete[] pHome;
#endif
}
mitk::Surface::Pointer mitk::PythonService::CopyVtkPolyDataFromPython( const std::string& stdvarName )
{
// access python module
PyObject *pyMod = PyImport_AddModule((char*)"__main__");
// global dictionarry
PyObject *pyDict = PyModule_GetDict(pyMod);
// python memory address
PyObject *pyAddr = nullptr;
// cpp address
size_t addr = 0;
mitk::Surface::Pointer surface = mitk::Surface::New();
QString command;
QString varName = QString::fromStdString( stdvarName );
command.append( QString("%1_addr_str = %1.GetAddressAsString(\"vtkPolyData\")\n").arg(varName) );
// remove 0x from the address
command.append( QString("%1_addr = int(%1_addr_str[5:],16)").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
// get address of the object
pyAddr = PyDict_GetItemString(pyDict,QString("%1_addr").arg(varName).toStdString().c_str());
// convert to long
addr = PyInt_AsLong(pyAddr);
MITK_DEBUG << "Python object address: " << addr;
// get the object
vtkPolyData* poly = (vtkPolyData*)((void*)addr);
surface->SetVtkPolyData(poly);
// delete helper variables from python stack
command = "";
command.append( QString("del %1_addr_str\n").arg(varName) );
command.append( QString("del %1_addr").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
return surface;
}
void QmitkPythonSnippets::on_AddSnippet_triggered(bool)
{
bool ok;
QString name = QInputDialog::getText(this,
tr("Add new snippet"),
tr("Name of snippet:"),
QLineEdit::Normal,
"newSnippet",
&ok);
if (ok && !name.isEmpty())
{
MITK_DEBUG("QmitkPythonSnippets") << "creating unique name for " << name.toStdString();
name = this->CreateUniqueName(name);
MITK_DEBUG("QmitkPythonSnippets") << "creating snippet " << name.toStdString();
d->m_Snippets[name] = "";
this->Update(name);
this->SaveStringMap( d->m_AutoSaveFileName, d->m_Snippets );
}
}
void QmitkPythonSnippets::on_Content_textChanged()
{
if( d->m_Content->isEnabled() )
{
QString name = d->m_Name->currentText();
QString snippet = d->m_Content->toPlainText();
d->m_Snippets[name] = snippet;
this->SaveStringMap( d->m_AutoSaveFileName, d->m_Snippets );
MITK_DEBUG("QmitkPythonSnippets") << "SaveStringMap successful";
}
}
void QmitkPythonSnippets::Update(const QString &name)
{
d->m_Name->clear();
d->m_Content->clear();
MITK_DEBUG("QmitkPythonSnippets") << "size of snippets " << d->m_Snippets.size();
QStringMap::const_iterator it = d->m_Snippets.begin();
while( it != d->m_Snippets.end() )
{
MITK_DEBUG("QmitkPythonSnippets") << "adding item " << it.key().toStdString();
d->m_Name->addItem( it.key() );
++it;
}
int index = d->m_Name->findText( name );
if( index >= 0 )
{
MITK_DEBUG("QmitkPythonSnippets") << "selecting index " << index;
d->m_Name->setCurrentIndex(index);
}
}
void mitk::IGTLDevice::RunCommunication(void (IGTLDevice::*ComFunction)(void), itk::FastMutexLock* mutex)
{
if (this->GetState() != Running)
return;
try
{
// keep lock until end of scope
MutexLockHolder communicationFinishedLockHolder(*mutex);
// Because m_StopCommunication is used by two threads, access has to be guarded
// by a mutex. To minimize thread locking, a local copy is used here
bool localStopCommunication;
// update the local copy of m_StopCommunication
this->m_StopCommunicationMutex->Lock();
localStopCommunication = this->m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
while ((this->GetState() == Running) && (localStopCommunication == false))
{
(this->*ComFunction)();
/* Update the local copy of m_StopCommunication */
this->m_StopCommunicationMutex->Lock();
localStopCommunication = m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
// time to relax
itksys::SystemTools::Delay(1);
}
}
catch (...)
{
mutex->Unlock();
this->StopCommunication();
MITK_ERROR("IGTLDevice::RunCommunication") << "Error while communicating. Thread stopped.";
//mitkThrowException(mitk::IGTException) << "Error while communicating. Thread stopped.";
}
// StopCommunication was called, thus the mode should be changed back to Ready now
// that the tracking loop has ended.
//this->SetState(Ready); //this is done elsewhere
MITK_DEBUG("IGTLDevice::RunCommunication") << "Reached end of communication.";
// returning from this function (and ThreadStartCommunication())
// this will end the thread
return;
}
bool mitk::PythonService::CopyToPythonAsVtkPolyData( mitk::Surface* surface, const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
std::ostringstream oss;
std::string addr = "";
QString command;
QString address;
oss << (void*) ( surface->GetVtkPolyData() );
// get the address
addr = oss.str();
// remove "0x"
address = QString::fromStdString(addr.substr(2));
command.append( QString("%1 = vtk.vtkPolyData(\"%2\")\n").arg(varName).arg(address) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
return true;
}
void QmitkPythonView::CreateQtPartControl(QWidget* parent)
{
d->m_PythonVariableStackTableView = new QmitkPythonVariableStackTableView;
d->m_PythonVariableStackTableView->SetDataStorage(this->GetDataStorage());
//d->m_PythonVariableStackTableView->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
QString snippetsFilePath = mitk::PluginActivator::m_XmlFilePath;
MITK_DEBUG("QmitkPythonView") << "got snippetsFilePath " << snippetsFilePath.toStdString();
d->m_PythonSnippets = new QmitkPythonSnippets(snippetsFilePath);
MITK_DEBUG("QmitkPythonView") << "initializing varStackSnippetsTab";
QTabWidget* varStackSnippetsTab = new QTabWidget;
varStackSnippetsTab->addTab( d->m_PythonVariableStackTableView, "Variable Stack" );
varStackSnippetsTab->addTab( d->m_PythonSnippets, "Snippets" );
varStackSnippetsTab->setTabPosition( QTabWidget::South );
MITK_DEBUG("QmitkPythonView") << "initializing m_PythonShell";
d->m_PythonShell = new QmitkCtkPythonShell;
MITK_DEBUG("QmitkPythonView") << "initializing m_TextEditor";
d->m_TextEditor = new QmitkPythonTextEditor;
MITK_DEBUG("QmitkPythonView") << "initializing tabWidgetConsoleEditor";
QTabWidget* tabWidgetConsoleEditor = new QTabWidget;
tabWidgetConsoleEditor->addTab( d->m_PythonShell, "Console" );
tabWidgetConsoleEditor->addTab( d->m_TextEditor, "Text Editor" );
tabWidgetConsoleEditor->setTabPosition( QTabWidget::South );
QList<int> sizes;
sizes << 1 << 3;
QSplitter* splitter = new QSplitter;
splitter->addWidget(varStackSnippetsTab);
splitter->addWidget(tabWidgetConsoleEditor);
splitter->setStretchFactor ( 0, 1 );
splitter->setStretchFactor ( 1, 3 );
QGridLayout* layout = new QGridLayout;
layout->addWidget( splitter, 0, 0 );
parent->setLayout(layout);
MITK_DEBUG("QmitkPythonView") << "creating connections for m_PythonSnippets";
connect( d->m_PythonSnippets, SIGNAL(PasteCommandRequested(QString)), d->m_PythonShell, SLOT(Paste(QString)) );
connect( d->m_PythonSnippets, SIGNAL(PasteCommandRequested(QString)), d->m_TextEditor, SLOT(Paste(QString)) );
}
bool mitk::PointSetInteractor::ExecuteAction( Action* action, mitk::StateEvent const* stateEvent )
{
bool ok = false;//for return type bool
//checking corresponding Data; has to be a PointSet or a subclass
mitk::PointSet* pointSet =
dynamic_cast<mitk::PointSet*>(m_DataNode->GetData());
if ( pointSet == NULL )
{
return false;
}
//get the timestep to support 3D+T
const mitk::Event *theEvent = stateEvent->GetEvent();
mitk::ScalarType timeInMS = 0.0;
//check if the current timestep has to be changed
if ( theEvent )
{
if (theEvent->GetSender() != NULL)
{
//additionaly to m_TimeStep we need timeInMS to satisfy the execution of the operations
timeInMS = theEvent->GetSender()->GetTime();
}
}
//for reading on the points, Id's etc
mitk::PointSet::DataType *itkPointSet = pointSet->GetPointSet( m_TimeStep );
if ( itkPointSet == NULL )
{
return false;
}
mitk::PointSet::PointsContainer *points = itkPointSet->GetPoints();
/*Each case must watch the type of the event!*/
switch (action->GetActionId())
{
case AcDONOTHING:
ok = true;
break;
case AcCHECKOPERATION:
//to check if the given Event is a DisplayPositionEvent.
{
mitk::DisplayPositionEvent const *dispPosEvent =
dynamic_cast <const mitk::DisplayPositionEvent *> (
stateEvent->GetEvent());
if (dispPosEvent != NULL)
{
mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
}
else
{
mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
}
ok = true;
break;
}
case AcADDPOINT:
// Declare two operations: one for the selected state: deselect the last
// one selected and select the new one the other operation is the add
// operation: There the first empty place have to be found and the new
// point inserted into that space
{
mitk::DisplayPositionEvent const *posEvent =
dynamic_cast < const mitk::DisplayPositionEvent * >
(stateEvent->GetEvent());
// Check if it is a DisplayEvent thrown in a 3D window. Then the
// z-information is missing. Returning false might end in the state
// full, but the last point couldn't be added, so the set wouldn't be
// full. So a extra Action that checks the operationtype has been added.
if ( posEvent == NULL )
{
return false;
}
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
// undo-supported deselect of all points in the DataList; if List is
// empty, then nothing will be unselected
this->UnselectAll( m_TimeStep, timeInMS );
// find the position, the point is to be added to: first entry with
// empty index. If the Set is empty, then start with 0. if not empty,
// then take the first index not occupied
int lastPosition = 0;
if (!points->empty())
{
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
if (!points->IndexExists(lastPosition))
break;
++it;
++lastPosition;
}
}
PointOperation* doOp = new mitk::PointOperation(
OpINSERT, timeInMS, itkPoint, lastPosition);
if (m_UndoEnabled)
{
// difference between OpDELETE and OpREMOVE is, that OpDELETE deletes
// a point at the end, and OpREMOVE deletes it from the given position
// remove is better, cause we need the position to add or remove the
// point anyway. We can get the last position from size()
PointOperation *undoOp = new mitk::PointOperation(
OpREMOVE, timeInMS, itkPoint, lastPosition);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp, "Add point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
//the point is added and directly selected in PintSet. So no need to call OpSELECTPOINT
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcINITMOVEMENT:
{
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
// start of the Movement is stored to calculate the undoKoordinate
// in FinishMovement
m_LastPoint = posEvent->GetWorldPosition();
// initialize a value to calculate the movement through all
// MouseMoveEvents from MouseClick to MouseRelease
m_SumVec.Fill(0);
ok = true;
break;
}
case AcMOVESELECTED://moves all selected Elements
{
mitk::PositionEvent const *posEvent = dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D newPoint, resultPoint;
newPoint = posEvent->GetWorldPosition();
// search the elements in the list that are selected then calculate the
// vector, because only with the vector we can move several elements in
// the same direction
// newPoint - lastPoint = vector
// then move all selected and set the lastPoint = newPoint.
// then add all vectors to a summeryVector (to be able to calculate the
// startpoint for undoOperation)
mitk::Vector3D dirVector = newPoint - m_LastPoint;
//sum up all Movement for Undo in FinishMovement
m_SumVec = m_SumVec + dirVector;
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
int position = it->Index();
if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
mitk::Point3D sumVec;
sumVec[0] = pt[0];
sumVec[1] = pt[1];
sumVec[2] = pt[2];
resultPoint = sumVec + dirVector;
PointOperation doOp(OpMOVE, timeInMS, resultPoint, position);
//execute the Operation
//here no undo is stored, because the movement-steps aren't interesting.
// only the start and the end is interisting to store for undo.
pointSet->ExecuteOperation(&doOp);
}
++it;
}
m_LastPoint = newPoint;//for calculation of the direction vector
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcREMOVEPOINT://remove the given Point from the list
{
//if the point to be removed is given by the positionEvent:
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent != NULL)
{
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
//State checkpointbut we also need the position in the list to remove it
if (position>=0)//found a point
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
//Undo
PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
timeInMS, itkPoint, position);
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet,
doOp, undoOp, "Remove point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
//only then a select of a point is possible!
if (pointSet->GetSize( m_TimeStep ) > 0)
{
this->SelectPoint(pointSet->Begin(m_TimeStep)->Index(), m_TimeStep, timeInMS);
}
ok = true;
}
}
else //no position is given so remove all selected elements
{
//delete all selected points
//search for the selected one and then declare the operations!
mitk::PointSet::PointsContainer::Iterator it, end;
it = points->Begin();
end = points->End();
int position = 0;
int previousExistingPosition = -1;//to recognize the last existing position; needed because the iterator gets invalid if the point is deleted!
int lastDelPrevExistPosition = -1; //the previous position of the last deleted point
while (it != end)
{
if (points->IndexExists(it->Index()))
{
//if point is selected
if ( pointSet->GetSelectInfo(it->Index(), m_TimeStep) )
{
//get the coordinates of that point to be undoable
PointSet::PointType selectedPoint = it->Value();
mitk::Point3D itkPoint;
itkPoint[0] = selectedPoint[0];
itkPoint[1] = selectedPoint[1];
itkPoint[2] = selectedPoint[2];
position = it->Index();
PointOperation* doOp = new mitk::PointOperation(OpREMOVE,
timeInMS, itkPoint, position);
//Undo
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpINSERT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet,
doOp, undoOp, "Remove point");
m_UndoController->SetOperationEvent(operationEvent);
}
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
//after delete the iterator is undefined, so start again
//count to the last existing entry
if (points->Size()>1 && points->IndexExists(previousExistingPosition))
{
for (it = points->Begin(); it != points->End(); it++)
{
if (it->Index() == (unsigned int) previousExistingPosition)
{
lastDelPrevExistPosition = previousExistingPosition;
break; //return if the iterator on the last existing position is found
}
}
}
else // size <= 1 or no previous existing position set
{
//search for the first existing position
for (it = points->Begin(); it != points->End(); it++)
if (points->IndexExists(it->Index()))
{
previousExistingPosition = it->Index();
break;
}
}
//now that we have set the iterator, lets get sure, that the next it++ will not crash!
if (it == end) { break; }
}//if
else
{
previousExistingPosition = it->Index();
}
}//if index exists
it++;
}//while
if (lastDelPrevExistPosition < 0)//the var has not been set because the first element was deleted and there was no prev position
lastDelPrevExistPosition = previousExistingPosition; //go to the end
/*
* now select the point before the point/points that was/were deleted
*/
if (pointSet->GetSize( m_TimeStep ) > 0) //only then a select of a point is possible!
{
if (points->IndexExists(lastDelPrevExistPosition))
{
this->SelectPoint( lastDelPrevExistPosition, m_TimeStep, timeInMS );
}
else
{
//select the first existing element
for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); it++)
if (points->IndexExists(it->Index()))
{
this->SelectPoint( it->Index(), m_TimeStep, timeInMS );
break;
}
}
}//if
ok = true;
}//else
}//case
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
// Remove all Points that have been set at once.
// TODO: Undo function not supported yet.
case AcREMOVEALL:
{
if ( !points->empty() )
{
PointSet::PointType pt;
mitk::PointSet::PointsContainer::Iterator it, end;
it = points->Begin();
end = points->End();
int position = 0;
while ( it != end )
{
position = it->Index();
if ( points->IndexExists( position ) )
{
pt = pointSet->GetPoint( position, m_TimeStep );
PointOperation doOp( OpREMOVE, timeInMS, pt, position );
++it;
pointSet->ExecuteOperation( &doOp );
}
else it++;
}
}
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
//Checking if the Point transmitted is close enough to one point. Then
//generate a new event with the point and let this statemaschine
//handle the event.
case AcCHECKELEMENT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent != NULL)
{
mitk::Point3D worldPoint = posEvent->GetWorldPosition();
int position = pointSet->SearchPoint( worldPoint, m_Precision, m_TimeStep );
if (position>=0)//found a point near enough to the given point
{
//get that point, the one meant by the user!
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
mitk::Point2D displPoint;
displPoint[0] = worldPoint[0]; displPoint[1] = worldPoint[1];
//new Event with information YES and with the correct point
mitk::PositionEvent newPosEvent(posEvent->GetSender(), Type_None,
BS_NoButton, BS_NoButton, Key_none, displPoint, pt);
mitk::StateEvent newStateEvent(EIDYES, &newPosEvent);
//call HandleEvent to leave the guard-state
this->HandleEvent( &newStateEvent );
ok = true;
}
else
{
//new Event with information NO
mitk::StateEvent newStateEvent(EIDNO, posEvent);
this->HandleEvent(&newStateEvent );
ok = true;
}
}
else
{
MITK_DEBUG("OperationError")<<this->GetType()<<" AcCHECKELEMENT expected PointOperation.";
mitk::DisplayPositionEvent const *disPosEvent =
dynamic_cast <const mitk::DisplayPositionEvent *> (
stateEvent->GetEvent());
if (disPosEvent != NULL)
{ //2d Koordinates for 3D Interaction; return false to redo
//the last statechange
mitk::StateEvent newStateEvent(EIDNO, disPosEvent);
this->HandleEvent(&newStateEvent);
ok = true;
}
}
break;
}
case AcCHECKONESELECTED:
//check if there is a point that is selected
{
if (pointSet->GetNumberOfSelected(m_TimeStep)>0)
{
mitk::StateEvent newStateEvent( EIDYES, theEvent);
this->HandleEvent( &newStateEvent );
}
else //not selected then call event EIDNO
{
//new Event with information NO
mitk::StateEvent newStateEvent( EIDNO, theEvent);
this->HandleEvent( &newStateEvent );
}
ok = true;
break;
}
case AcCHECKSELECTED:
/*check, if the given point is selected:
if no, then send EIDNO
if yes, then send EIDYES*/
// check, if: because of the need to look up the point again, it is
// possible, that we grab the wrong point in case there are two same points
// so maybe we do have to set a global index for further computation,
// as long, as the mouse is moved...
{
int position = -1;
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D worldPoint = posEvent->GetWorldPosition();
position = pointSet->SearchPoint(worldPoint, m_Precision, m_TimeStep);
if (position>=0)
{
mitk::PositionEvent const *newPosEvent =
new mitk::PositionEvent(posEvent->GetSender(),
posEvent->GetType(), posEvent->GetButton(),
posEvent->GetButtonState(), posEvent->GetKey(),
posEvent->GetDisplayPosition(), posEvent->GetWorldPosition());
//if selected on true, then call Event EIDYES
if (pointSet->GetSelectInfo(position, m_TimeStep))
{
mitk::StateEvent newStateEvent( EIDYES, newPosEvent );
this->HandleEvent( &newStateEvent );
ok = true;
//saving the spot for calculating the direction vector in moving
m_LastPoint = posEvent->GetWorldPosition();
}
else //not selected then call event EIDNO
{
//new Event with information NO
mitk::StateEvent newStateEvent( EIDNO, newPosEvent );
this->HandleEvent( &newStateEvent );
ok = true;
}
delete newPosEvent;
}
//the position wasn't set properly. If necessary: search the given
//point in list and set var position
else
{
/*
mitk::StatusBar::GetInstance()->DisplayText(
"Message from mitkPointSetInteractor: Error in Actions! Check Config XML-file",
10000);
*/
ok = false;
}
break;
}
//generate Events if the set will be full after the addition of the
// point or not.
case AcCHECKNMINUS1:
{
// number of points not limited->pass on
// "Amount of points in Set is smaller then N-1"
if (m_N<0)
{
mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else
{
if (pointSet->GetSize( m_TimeStep ) < m_N-1 )
//pointset after addition won't be full
{
mitk::StateEvent newStateEvent(EIDSTSMALERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else
//after the addition of a point, the container will be full
{
mitk::StateEvent newStateEvent(EIDSTLARGERNMINUS1, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}//else
}//else
}
break;
case AcCHECKEQUALS1:
{
//the number of points in the list is 1 (or smaler)
if (pointSet->GetSize( m_TimeStep ) <= 1)
{
mitk::StateEvent newStateEvent(EIDYES, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else //more than 1 points in list, so stay in the state!
{
mitk::StateEvent newStateEvent(EIDNO, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
break;
case AcCHECKNUMBEROFPOINTS:
{
//the number of points in the list is 1 (or smaler), so will be empty after delete
if (pointSet->GetSize( m_TimeStep ) <= 1)
{
mitk::StateEvent newStateEvent(EIDEMPTY, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
else if (pointSet->GetSize( m_TimeStep ) <= m_N || m_N <= -1)
//m_N is set to unlimited points allowed or more than 1 points in list, but not full, so stay in the state!
{
// if the number of points equals m_N and no point of the point set is selected switch to state EIDEQUALSN
if ((pointSet->GetSize( m_TimeStep ) == m_N)&&(pointSet->GetNumberOfSelected()==0))
{
mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
// if the number of points is small than or equal m_N and point(s) are selected stay in state
else
{
mitk::StateEvent newStateEvent(EIDSMALLERN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
else
//pointSet->GetSize( m_TimeStep ) >=m_N.
// This can happen if the points were not added
// by interaction but by loading a .mps file
{
mitk::StateEvent newStateEvent(EIDEQUALSN, stateEvent->GetEvent());
this->HandleEvent( &newStateEvent );
ok = true;
}
}
break;
case AcSELECTPICKEDOBJECT://and deselect others
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL) return false;
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
//State checkpoint but we also need the position in the list to move it
if (position>=0)//found a point
{
//first deselect the other points
//undoable deselect of all points in the DataList
this->UnselectAll( m_TimeStep, timeInMS);
PointOperation* doOp = new mitk::PointOperation(OpSELECTPOINT,
timeInMS, itkPoint, position);
//Undo
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpDESELECTPOINT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
ok = true;
}
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcDESELECTOBJECT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
mitk::Point3D itkPoint;
itkPoint = posEvent->GetWorldPosition();
//search the point in the list
int position = pointSet->SearchPoint(itkPoint, 0.0, m_TimeStep);
//distance set to 0, cause we already got the exact point from last
// State checkpoint but we also need the position in the list to move it
if (position>=0)//found a point
{
//Undo
PointOperation* doOp = new mitk::PointOperation(OpDESELECTPOINT,
timeInMS, itkPoint, position);
if (m_UndoEnabled) //write to UndoMechanism
{
PointOperation* undoOp = new mitk::PointOperation(OpSELECTPOINT,
timeInMS, itkPoint, position);
OperationEvent *operationEvent = new OperationEvent(pointSet, doOp, undoOp);
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
ok = true;
}
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcDESELECTALL:
{
//undo-supported able deselect of all points in the DataList
this->UnselectAll( m_TimeStep, timeInMS );
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcFINISHMOVEMENT:
{
mitk::PositionEvent const *posEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
if (posEvent == NULL)
return false;
//finish the movement:
//the final point is m_LastPoint
//m_SumVec stores the movement in a vector
//the operation would not be necessary, but we need it for the undo Operation.
//m_LastPoint is for the Operation
//the point for undoOperation calculates from all selected
//elements (point) - m_SumVec
//search all selected elements and move them with undo-functionality.
mitk::PointSet::PointsIterator it, end;
it = points->Begin();
end = points->End();
while( it != end )
{
int position = it->Index();
if ( pointSet->GetSelectInfo(position, m_TimeStep) )//if selected
{
PointSet::PointType pt = pointSet->GetPoint(position, m_TimeStep);
Point3D itkPoint;
itkPoint[0] = pt[0];
itkPoint[1] = pt[1];
itkPoint[2] = pt[2];
PointOperation* doOp = new mitk::PointOperation(OpMOVE,
timeInMS, itkPoint, position);
if ( m_UndoEnabled )//&& (posEvent->GetType() == mitk::Type_MouseButtonRelease)
{
//set the undo-operation, so the final position is undo-able
//calculate the old Position from the already moved position - m_SumVec
mitk::Point3D undoPoint = ( itkPoint - m_SumVec );
PointOperation* undoOp =
new mitk::PointOperation(OpMOVE, timeInMS, undoPoint, position);
OperationEvent *operationEvent =
new OperationEvent(pointSet, doOp, undoOp, "Move point");
m_UndoController->SetOperationEvent(operationEvent);
}
//execute the Operation
pointSet->ExecuteOperation(doOp);
if ( !m_UndoEnabled )
delete doOp;
}
++it;
}
//set every variable for movement calculation to zero
// commented out: increases usebility in derived classes.
/*m_LastPoint.Fill(0);
m_SumVec.Fill(0);*/
//increase the GroupEventId, so that the Undo goes to here
this->IncCurrGroupEventId();
ok = true;
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case AcCLEAR:
{
this->Clear( m_TimeStep, timeInMS );
// Update the display
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
default:
return Superclass::ExecuteAction( action, stateEvent );
}
// indicate modification of data tree node
m_DataNode->Modified();
return ok;
}
mitk::PersistenceService::~PersistenceService()
{
MITK_DEBUG("mitk::PersistenceService") << "destructing PersistenceService";
}
mitk::PythonService::PythonService()
: m_ItkWrappingAvailable( true ), m_OpenCVWrappingAvailable( true ), m_VtkWrappingAvailable( true ), m_ErrorOccured( false )
{
{
MITK_DEBUG << "will init python if necessary";
}
bool pythonInitialized = static_cast<bool>( Py_IsInitialized() ); //m_PythonManager.isPythonInitialized() );
{
MITK_DEBUG << "pythonInitialized " << pythonInitialized;
MITK_DEBUG << "m_PythonManager.isPythonInitialized() " << m_PythonManager.isPythonInitialized();
}
// due to strange static var behaviour on windows Py_IsInitialized() returns correct value while
// m_PythonManager.isPythonInitialized() does not because it has been constructed and destructed again
if( !m_PythonManager.isPythonInitialized() )
{
try
{
//TODO a better way to do this
#ifndef WIN32
#if defined (__APPLE__) || defined(MACOSX)
const char* library = "libpython${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}.dylib";
#else
const char* library = "libpython${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}.so";
#endif
dlerror();
if(dlopen(library, RTLD_NOW | RTLD_GLOBAL) == 0 )
{
mitkThrow() << "Python runtime could not be loaded: " << dlerror();
}
#endif
std::string programPath = mitk::IOUtil::GetProgramPath();
QDir programmDir( QString( programPath.c_str() ).append("/Python") );
QString pythonCommand;
// TODO: Check this in the modernization branch with an installer
// Set the pythonpath variable depending if
// we have an installer or development environment
if ( programmDir.exists() ) {
// runtime directory used in installers
pythonCommand.append( QString("import site, sys\n") );
pythonCommand.append( QString("sys.path.append('')\n") );
pythonCommand.append( QString("sys.path.append('%1')\n").arg(programPath.c_str()) );
pythonCommand.append( QString("sys.path.append('%1/Python')").arg(programPath.c_str()) );
// development
} else {
pythonCommand.append( QString("import site, sys\n") );
pythonCommand.append( QString("sys.path.append('')\n") );
pythonCommand.append( QString("sys.path.append('%1')\n").arg(EXTERNAL_DIST_PACKAGES) );
pythonCommand.append( QString("\nsite.addsitedir('%1')").arg(EXTERNAL_SITE_PACKAGES) );
}
if( pythonInitialized )
m_PythonManager.setInitializationFlags(PythonQt::RedirectStdOut|PythonQt::PythonAlreadyInitialized);
else
m_PythonManager.setInitializationFlags(PythonQt::RedirectStdOut);
// set python home if own runtime is used
#ifdef USE_MITK_BUILTIN_PYTHON
QString pythonHome;
if ( programmDir.exists() )
pythonHome.append(QString("%1/Python").arg(programPath.c_str()));
else
pythonHome.append(PYTHONHOME);
if(pHome) delete[] pHome;
pHome = new char[pythonHome.toStdString().length() + 1];
strcpy(pHome,pythonHome.toStdString().c_str());
Py_SetPythonHome(pHome);
MITK_DEBUG("PythonService") << "PythonHome: " << pHome;
#endif
MITK_DEBUG("PythonService") << "initalizing python";
m_PythonManager.initialize();
#ifdef USE_MITK_BUILTIN_PYTHON
PyObject* dict = PyDict_New();
// Import builtin modules
if (PyDict_GetItemString(dict, "__builtins__") == nullptr)
{
PyObject* builtinMod = PyImport_ImportModule("__builtin__");
if (builtinMod == nullptr ||
PyDict_SetItemString(dict, "__builtins__", builtinMod) != 0)
{
Py_DECREF(dict);
Py_XDECREF(dict);
return;
}
Py_DECREF(builtinMod);
}
#endif
MITK_DEBUG("PythonService")<< "Python Search paths: " << Py_GetPath();
MITK_DEBUG("PythonService") << "python initalized";
//MITK_DEBUG("PythonService") << "registering python paths" << PYTHONPATH_COMMAND;
m_PythonManager.executeString( pythonCommand, ctkAbstractPythonManager::FileInput );
}
catch (...)
{
MITK_DEBUG("PythonService") << "exception initalizing python";
}
}
}
bool mitk::PersistenceService::Load(const std::string &fileName, bool enforceReload)
{
this->Initialize();
bool load = false;
std::string theFile = fileName;
if (theFile.empty())
theFile = PersistenceService::GetDefaultPersistenceFile();
MITK_DEBUG << "Load persistence data from file: " << theFile;
if (!itksys::SystemTools::FileExists(theFile.c_str()))
return false;
bool xmlFile = false;
if (itksys::SystemTools::GetFilenameLastExtension(theFile.c_str()) == ".xml")
xmlFile = true;
if (enforceReload == false)
{
bool loadTheFile = true;
std::map<std::string, long int>::iterator it = m_FileNamesToModifiedTimes.find(theFile);
long int currentModifiedTime = itksys::SystemTools::ModifiedTime(theFile.c_str());
if (it != m_FileNamesToModifiedTimes.end())
{
long int knownModifiedTime = (*it).second;
if (knownModifiedTime >= currentModifiedTime)
{
loadTheFile = false;
}
}
if (loadTheFile)
m_FileNamesToModifiedTimes[theFile] = currentModifiedTime;
else
return true;
}
if (xmlFile)
{
load = m_PropertyListsXmlFileReaderAndWriter->ReadLists(theFile, m_PropertyLists);
}
else
{
if (m_SceneIO.IsNull())
{
m_SceneIO = mitk::SceneIO::New();
}
DataStorage::Pointer ds = m_SceneIO->LoadScene(theFile);
load = (m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedNodes()->size() == 0) &&
(m_SceneIO->GetFailedNodes() == 0 || m_SceneIO->GetFailedProperties()->IsEmpty());
if (load)
{
this->RestorePropertyListsFromPersistentDataNodes(ds);
}
}
if (!load)
{
MITK_DEBUG("mitk::PersistenceService") << "loading of scene files failed";
return load;
}
return load;
}
void QmitkKurtosisWidget::SetData(KurtosisFilterType::KurtosisSnapshot snap)
{
this->Clear();
if( snap.bvalues.empty() )
return;
double max_y_val = 1.4 * fmax( snap.measurements[0], snap.m_BzeroFit );
auto logScale = new QwtLogScaleEngine();
m_Plot->setAxisScaleEngine(0, logScale );
m_Plot->setAxisScale(0, 0.1, max_y_val );
QString s("D=%1, K=%2");
s = s.arg( snap.m_D, 4); s = s.arg( snap.m_K, 4);
// insert formatted value string to legend (curve without pen)
int curveId = this->InsertCurve( s.toLatin1(), QColor( Qt::black ) );
this->SetCurvePen( curveId, QPen( Qt::NoPen ) );
QPen pen;
pen.setColor( QColor( Qt::red ));
pen.setWidth(2);
pen.setStyle( Qt::PenStyle::DashLine );
// get the x-axis maximum
const double max_bvalue = snap.bvalues.max_value();
//
// Data-points
//
auto measured_values = toStdVec( snap.measurements );
double y_bzero = measured_values[0];
if( snap.m_fittedBZero )
{
/*auto c_measurements_curve = this->InsertCurve( "Corrected measured values with fitted b=0" );
this->SetCurveData( c_measurements_curve, toStdVec( snap.fit_bvalues ), toStdVec( snap.fit_measurements / snap.m_BzeroFit ) );
this->SetCurvePen( c_measurements_curve, QPen(Qt::NoPen) );
QwtSymbol* whiteDiamond = new QwtSymbol(QwtSymbol::Diamond, QColor(Qt::white), QColor(Qt::black), QSize(8,8));
this->SetCurveSymbol( c_measurements_curve, whiteDiamond );*/
std::vector<double> single_bzero;
single_bzero.push_back(0);
std::vector<double> fitted_bzero;
fitted_bzero.push_back( snap.m_BzeroFit );
auto c_measurements_bzero = this->InsertCurve( "Fitted b=0" );
this->SetCurveData( c_measurements_bzero, single_bzero, fitted_bzero );
this->SetCurvePen( c_measurements_bzero, QPen(Qt::NoPen) );
QwtSymbol* blackDiamond = new QwtSymbol(QwtSymbol::Diamond, QColor(Qt::black), QColor(Qt::black), QSize(8,8));
this->SetCurveSymbol( c_measurements_bzero, blackDiamond );
y_bzero = snap.m_BzeroFit;
MITK_DEBUG("Kurtosis.Widget.Bzero") << "[Fitted] " << snap.m_BzeroFit << ": [Measured] " << snap.measurements[0];
}
auto measurements_curve = this->InsertCurve( "Measured values" );
this->SetCurveData( measurements_curve, toStdVec( snap.bvalues ), measured_values );
this->SetCurvePen( measurements_curve, QPen(Qt::NoPen) );
QwtSymbol* redDiamond = new QwtSymbol(QwtSymbol::Diamond, QColor(Qt::red), QColor(Qt::red), QSize(8,8));
this->SetCurveSymbol( measurements_curve, redDiamond );
//
// Kurtosis - full modelled signal
//
pen.setColor( QColor( Qt::black ));
pen.setStyle( Qt::SolidLine );
const unsigned int num_samples = 50;
vnl_vector<double> x_K_model(num_samples);
vnl_vector<double> y_K_model(num_samples);
vnl_vector<double> y_D_model(num_samples);
const double x_tics_offset = max_bvalue / static_cast<double>( num_samples );
for( unsigned int i=0; i<num_samples; ++i)
{
x_K_model[i] = i * x_tics_offset;
double bval = x_K_model[i];
y_K_model[i] = y_bzero * exp( -bval * snap.m_D + bval*bval * snap.m_D * snap.m_D * snap.m_K / 6.0 );
y_D_model[i] = y_bzero * exp( -bval * snap.m_D );
}
auto kurtosis_curve = this->InsertCurve( "Resulting fit of the model" );
this->SetCurveData( kurtosis_curve, toStdVec( x_K_model ), toStdVec( y_K_model ) );
this->SetCurvePen( kurtosis_curve, pen );
this->SetCurveAntialiasingOn( kurtosis_curve );
auto d_curve = this->InsertCurve( "D-part of the fitted model" );
this->SetCurveData( d_curve, toStdVec( x_K_model ), toStdVec( y_D_model ) );
pen.setColor( QColor( Qt::red));
pen.setStyle( Qt::PenStyle::DashLine );
this->SetCurvePen( d_curve, pen );
this->SetCurveAntialiasingOn( d_curve );
//
// add Legend
//
auto legend = new QwtLegend();
legend->setMaxColumns(3);
m_Plot->insertLegend( legend, QwtPlot::BottomLegend );
this->Replot();
}
mitk::Image::Pointer mitk::PythonService::CopySimpleItkImageFromPython(const std::string &stdvarName)
{
double*ds = nullptr;
// access python module
PyObject *pyMod = PyImport_AddModule((char*)"__main__");
// global dictionarry
PyObject *pyDict = PyModule_GetDict(pyMod);
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::Vector3D spacing;
mitk::Point3D origin;
QString command;
QString varName = QString::fromStdString( stdvarName );
command.append( QString("%1_numpy_array = sitk.GetArrayFromImage(%1)\n").arg(varName) );
command.append( QString("%1_spacing = numpy.asarray(%1.GetSpacing())\n").arg(varName) );
command.append( QString("%1_origin = numpy.asarray(%1.GetOrigin())\n").arg(varName) );
command.append( QString("%1_dtype = %1_numpy_array.dtype.name\n").arg(varName) );
command.append( QString("%1_direction = numpy.asarray(%1.GetDirection())\n").arg(varName) );
command.append( QString("%1_nrComponents = numpy.asarray(%1.GetNumberOfComponentsPerPixel())\n").arg(varName));
command.append( QString("%1_dtype = %1_numpy_array.dtype.name\n").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
PyObject* py_dtype = PyDict_GetItemString(pyDict,QString("%1_dtype").arg(varName).toStdString().c_str() );
std::string dtype = PyString_AsString(py_dtype);
PyArrayObject* py_data = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_numpy_array").arg(varName).toStdString().c_str() );
PyArrayObject* py_spacing = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_spacing").arg(varName).toStdString().c_str() );
PyArrayObject* py_origin = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_origin").arg(varName).toStdString().c_str() );
PyArrayObject* py_direction = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_direction").arg(varName).toStdString().c_str() );
PyArrayObject* py_nrComponents = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_nrComponents").arg(varName).toStdString().c_str() );
unsigned int nr_Components = *(reinterpret_cast<unsigned int*>(PyArray_DATA(py_nrComponents)));
unsigned int nr_dimensions = PyArray_NDIM(py_data);
if (nr_Components > 1) // for VectorImages the last dimension in the numpy array are the vector components.
{
--nr_dimensions;
}
mitk::PixelType pixelType = DeterminePixelType(dtype, nr_Components, nr_dimensions);
unsigned int* dimensions = new unsigned int[nr_dimensions];
// fill backwards , nd data saves dimensions in opposite direction
for( unsigned i = 0; i < nr_dimensions; ++i )
{
dimensions[i] = PyArray_DIMS(py_data)[nr_dimensions - 1 - i];
}
mitkImage->Initialize(pixelType, nr_dimensions, dimensions);
mitkImage->SetChannel(PyArray_DATA(py_data));
ds = reinterpret_cast<double*>(PyArray_DATA(py_spacing));
spacing[0] = ds[0];
spacing[1] = ds[1];
spacing[2] = ds[2];
mitkImage->GetGeometry()->SetSpacing(spacing);
ds = reinterpret_cast<double*>(PyArray_DATA(py_origin));
origin[0] = ds[0];
origin[1] = ds[1];
origin[2] = ds[2];
mitkImage->GetGeometry()->SetOrigin(origin);
itk::Matrix<double,3,3> py_transform;
ds = reinterpret_cast<double*>(PyArray_DATA(py_direction));
py_transform[0][0] = ds[0];
py_transform[0][1] = ds[1];
py_transform[0][2] = ds[2];
py_transform[1][0] = ds[3];
py_transform[1][1] = ds[4];
py_transform[1][2] = ds[5];
py_transform[2][0] = ds[6];
py_transform[2][1] = ds[7];
py_transform[2][2] = ds[8];
mitk::AffineTransform3D::Pointer affineTransform = mitkImage->GetGeometry()->GetIndexToWorldTransform();
itk::Matrix<double,3,3> transform = py_transform * affineTransform->GetMatrix();
affineTransform->SetMatrix(transform);
mitkImage->GetGeometry()->SetIndexToWorldTransform(affineTransform);
// mitk::AffineTransform3D::New();
//mitkImage->GetGeometry()->SetIndexToWorldTransform();
// cleanup
command.clear();
command.append( QString("del %1_numpy_array\n").arg(varName) );
command.append( QString("del %1_dtype\n").arg(varName) );
command.append( QString("del %1_spacing\n").arg(varName) );
command.append( QString("del %1_origin\n").arg(varName) );
command.append( QString("del %1_direction\n").arg(varName) );
command.append( QString("del %1_nrComponents\n").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
delete[] dimensions;
return mitkImage;
}
bool mitk::PythonService::CopyToPythonAsCvImage( mitk::Image* image, const std::string& stdvarName )
{
QString varName = QString::fromStdString( stdvarName );
QString command;
unsigned int* imgDim = image->GetDimensions();
int npy_nd = 1;
// access python module
PyObject *pyMod = PyImport_AddModule((char*)"__main__");
// global dictionary
PyObject *pyDict = PyModule_GetDict(pyMod);
mitk::PixelType pixelType = image->GetPixelType();
PyObject* npyArray = nullptr;
mitk::ImageReadAccessor racc(image);
void* array = (void*) racc.GetData();
// save the total number of elements here (since the numpy array is one dimensional)
npy_intp* npy_dims = new npy_intp[1];
npy_dims[0] = imgDim[0];
/**
* Build a string in the format [1024,1028,1]
* to describe the dimensionality. This is needed for simple itk
* to know the dimensions of the image
*/
QString dimensionString;
dimensionString.append(QString("["));
dimensionString.append(QString::number(imgDim[0]));
// ToDo: check if we need this
for (unsigned i = 1; i < 3; ++i)
// always three because otherwise the 3d-geometry gets destroyed
// (relevant for backtransformation of simple itk image to mitk.
{
dimensionString.append(QString(","));
dimensionString.append(QString::number(imgDim[i]));
npy_dims[0] *= imgDim[i];
}
dimensionString.append("]");
// the next line is necessary for vectorimages
npy_dims[0] *= pixelType.GetNumberOfComponents();
// default pixeltype: unsigned short
NPY_TYPES npy_type = NPY_USHORT;
if( pixelType.GetComponentType() == itk::ImageIOBase::DOUBLE ) {
npy_type = NPY_DOUBLE;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::FLOAT ) {
npy_type = NPY_FLOAT;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::SHORT) {
npy_type = NPY_SHORT;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::CHAR ) {
npy_type = NPY_BYTE;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::INT ) {
npy_type = NPY_INT;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::LONG ) {
npy_type = NPY_LONG;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UCHAR ) {
npy_type = NPY_UBYTE;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UINT ) {
npy_type = NPY_UINT;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::ULONG ) {
npy_type = NPY_LONG;
} else if( pixelType.GetComponentType() == itk::ImageIOBase::USHORT ) {
npy_type = NPY_USHORT;
}
else {
MITK_WARN << "not a recognized pixeltype";
return false;
}
// creating numpy array
import_array1 (true);
npyArray = PyArray_SimpleNewFromData(npy_nd,npy_dims,npy_type,array);
// add temp array it to the python dictionary to access it in python code
const int status = PyDict_SetItemString( pyDict,QString("%1_numpy_array")
.arg(varName).toStdString().c_str(),
npyArray );
// sanity check
if ( status != 0 )
return false;
command.append( QString("import numpy as np\n"));
//command.append( QString("if '%1' in globals():\n").arg(varName));
//command.append( QString(" del %1\n").arg(varName));
command.append( QString("%1_array_tmp=%1_numpy_array.copy()\n").arg(varName));
command.append( QString("%1_array_tmp=%1_array_tmp.reshape(%2,%3,%4)\n").arg( varName,
QString::number(imgDim[1]),
QString::number(imgDim[0]),
QString::number(pixelType.GetNumberOfComponents())));
command.append( QString("%1 = %1_array_tmp[:,...,::-1]\n").arg(varName));
command.append( QString("del %1_numpy_array\n").arg(varName) );
command.append( QString("del %1_array_tmp").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute( command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
return true;
}
void QmitkCtkPythonShell::executeCommand(const QString& command)
{
MITK_DEBUG("QmitkCtkPythonShell") << "executing command " << command.toStdString();
ctkPythonConsole::executeCommand(command);
d->m_PythonService->NotifyObserver(command.toStdString());
}
bool mitk::PythonService::CopyToPythonAsSimpleItkImage(mitk::Image *image, const std::string &stdvarName)
{
QString varName = QString::fromStdString( stdvarName );
QString command;
unsigned int* imgDim = image->GetDimensions();
int npy_nd = 1;
// access python module
PyObject *pyMod = PyImport_AddModule((char*)"__main__");
// global dictionary
PyObject *pyDict = PyModule_GetDict(pyMod);
const mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
const mitk::Point3D origin = image->GetGeometry()->GetOrigin();
mitk::PixelType pixelType = image->GetPixelType();
itk::ImageIOBase::IOPixelType ioPixelType = image->GetPixelType().GetPixelType();
PyObject* npyArray = nullptr;
mitk::ImageReadAccessor racc(image);
void* array = (void*) racc.GetData();
mitk::Vector3D xDirection;
mitk::Vector3D yDirection;
mitk::Vector3D zDirection;
const vnl_matrix_fixed<ScalarType, 3, 3> &transform =
image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
mitk::Vector3D s = image->GetGeometry()->GetSpacing();
// ToDo: Check if this is a collumn or row vector from the matrix.
// right now it works but not sure for rotated geometries
mitk::FillVector3D(xDirection, transform[0][0]/s[0], transform[0][1]/s[1], transform[0][2]/s[2]);
mitk::FillVector3D(yDirection, transform[1][0]/s[0], transform[1][1]/s[1], transform[1][2]/s[2]);
mitk::FillVector3D(zDirection, transform[2][0]/s[0], transform[2][1]/s[1], transform[2][2]/s[2]);
// save the total number of elements here (since the numpy array is one dimensional)
npy_intp* npy_dims = new npy_intp[1];
npy_dims[0] = imgDim[0];
/**
* Build a string in the format [1024,1028,1]
* to describe the dimensionality. This is needed for simple itk
* to know the dimensions of the image
*/
QString dimensionString;
dimensionString.append(QString("["));
dimensionString.append(QString::number(imgDim[0]));
for (unsigned i = 1; i < 3; ++i)
// always three because otherwise the 3d-geometry gets destroyed
// (relevant for backtransformation of simple itk image to mitk.
{
dimensionString.append(QString(","));
dimensionString.append(QString::number(imgDim[i]));
npy_dims[0] *= imgDim[i];
}
dimensionString.append("]");
// the next line is necessary for vectorimages
npy_dims[0] *= pixelType.GetNumberOfComponents();
// default pixeltype: unsigned short
NPY_TYPES npy_type = NPY_USHORT;
std::string sitk_type = "sitkUInt8";
if( ioPixelType == itk::ImageIOBase::SCALAR )
{
if( pixelType.GetComponentType() == itk::ImageIOBase::DOUBLE ) {
npy_type = NPY_DOUBLE;
sitk_type = "sitkFloat64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::FLOAT ) {
npy_type = NPY_FLOAT;
sitk_type = "sitkFloat32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::SHORT) {
npy_type = NPY_SHORT;
sitk_type = "sitkInt16";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::CHAR ) {
npy_type = NPY_BYTE;
sitk_type = "sitkInt8";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::INT ) {
npy_type = NPY_INT;
sitk_type = "sitkInt32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::LONG ) {
npy_type = NPY_LONG;
sitk_type = "sitkInt64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UCHAR ) {
npy_type = NPY_UBYTE;
sitk_type = "sitkUInt8";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UINT ) {
npy_type = NPY_UINT;
sitk_type = "sitkUInt32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::ULONG ) {
npy_type = NPY_LONG;
sitk_type = "sitkUInt64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::USHORT ) {
npy_type = NPY_USHORT;
sitk_type = "sitkUInt16";
}
}
else if ( ioPixelType == itk::ImageIOBase::VECTOR ||
ioPixelType == itk::ImageIOBase::RGB ||
ioPixelType == itk::ImageIOBase::RGBA
)
{
if( pixelType.GetComponentType() == itk::ImageIOBase::DOUBLE ) {
npy_type = NPY_DOUBLE;
sitk_type = "sitkVectorFloat64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::FLOAT ) {
npy_type = NPY_FLOAT;
sitk_type = "sitkVectorFloat32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::SHORT) {
npy_type = NPY_SHORT;
sitk_type = "sitkVectorInt16";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::CHAR ) {
npy_type = NPY_BYTE;
sitk_type = "sitkVectorInt8";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::INT ) {
npy_type = NPY_INT;
sitk_type = "sitkVectorInt32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::LONG ) {
npy_type = NPY_LONG;
sitk_type = "sitkVectorInt64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UCHAR ) {
npy_type = NPY_UBYTE;
sitk_type = "sitkVectorUInt8";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::UINT ) {
npy_type = NPY_UINT;
sitk_type = "sitkVectorUInt32";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::ULONG ) {
npy_type = NPY_LONG;
sitk_type = "sitkVectorUInt64";
} else if( pixelType.GetComponentType() == itk::ImageIOBase::USHORT ) {
npy_type = NPY_USHORT;
sitk_type = "sitkVectorUInt16";
}
}
else {
MITK_WARN << "not a recognized pixeltype";
return false;
}
// creating numpy array
import_array1 (true);
npyArray = PyArray_SimpleNewFromData(npy_nd,npy_dims,npy_type,array);
// add temp array it to the python dictionary to access it in python code
const int status = PyDict_SetItemString( pyDict,QString("%1_numpy_array")
.arg(varName).toStdString().c_str(),
npyArray );
// sanity check
if ( status != 0 )
return false;
command.append( QString("%1 = sitk.Image(%2,sitk.%3,%4)\n").arg(varName)
.arg(dimensionString)
.arg(QString(sitk_type.c_str())).arg(QString::number(pixelType.GetNumberOfComponents())) );
command.append( QString("%1.SetSpacing([%2,%3,%4])\n").arg(varName)
.arg(QString::number(spacing[0]))
.arg(QString::number(spacing[1]))
.arg(QString::number(spacing[2])) );
command.append( QString("%1.SetOrigin([%2,%3,%4])\n").arg(varName)
.arg(QString::number(origin[0]))
.arg(QString::number(origin[1]))
.arg(QString::number(origin[2])) );
command.append( QString("%1.SetDirection([%2,%3,%4,%5,%6,%7,%8,%9,%10])\n").arg(varName)
.arg(QString::number(xDirection[0]))
.arg(QString::number(xDirection[1]))
.arg(QString::number(xDirection[2]))
.arg(QString::number(yDirection[0]))
.arg(QString::number(yDirection[1]))
.arg(QString::number(yDirection[2]))
.arg(QString::number(zDirection[0]))
.arg(QString::number(zDirection[1]))
.arg(QString::number(zDirection[2]))
);
// directly access the cpp api from the lib
command.append( QString("_SimpleITK._SetImageFromArray(%1_numpy_array,%1)\n").arg(varName) );
command.append( QString("del %1_numpy_array").arg(varName) );
MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString();
this->Execute( command.toStdString(), IPythonService::MULTI_LINE_COMMAND );
return true;
}
