mitk::StdFunctionCommand::ActionFunction mitk::DisplayActionEventFunctions::SetLevelWindowAction()
{
auto actionFunction = [](const itk::EventObject& displayInteractorEvent)
{
if (DisplaySetLevelWindowEvent().CheckEvent(&displayInteractorEvent))
{
const DisplaySetLevelWindowEvent* displayActionEvent = dynamic_cast<const DisplaySetLevelWindowEvent*>(&displayInteractorEvent);
const BaseRenderer::Pointer sendingRenderer = displayActionEvent->GetSender();
if (nullptr == sendingRenderer)
{
return;
}
// get the the topmost visible image of the sending renderer
DataStorage::Pointer storage = sendingRenderer->GetDataStorage();
DataStorage::SetOfObjects::ConstPointer allImageNodes = storage->GetSubset(NodePredicateDataType::New("Image"));
Point3D worldposition;
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(displayActionEvent->GetInteractionEvent());
sendingRenderer->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), worldposition);
auto globalCurrentTimePoint = sendingRenderer->GetTime();
DataNode::Pointer node = FindTopmostVisibleNode(allImageNodes, worldposition, globalCurrentTimePoint, sendingRenderer);
if (node.IsNull())
{
return;
}
LevelWindow levelWindow = LevelWindow();
node->GetLevelWindow(levelWindow);
ScalarType level = levelWindow.GetLevel();
ScalarType window = levelWindow.GetWindow();
level += displayActionEvent->GetLevel();
window += displayActionEvent->GetWindow();
levelWindow.SetLevelWindow(level, window);
auto* levelWindowProperty = dynamic_cast<LevelWindowProperty*>(node->GetProperty("levelwindow"));
if (nullptr != levelWindowProperty)
{
levelWindowProperty->SetLevelWindow(levelWindow);
sendingRenderer->GetRenderingManager()->RequestUpdateAll();
}
}
};
return actionFunction;
}
void DataStorageEditorInputFactory::SaveState(const berry::IMemento::Pointer& memento, const DataStorageEditorInput* input)
{
IDataStorageReference::Pointer dataStorageRef = input->GetDataStorageReference();
if (dataStorageRef)
{
QString label = dataStorageRef->GetLabel();
DataStorage::Pointer dataStorage = dataStorageRef->GetDataStorage();
if (dataStorage)
{
memento->PutString(TAG_LABEL, label);
auto nodes = dataStorage->GetAll();
for(auto nodeIter = nodes.begin(); nodeIter != nodes.end(); ++nodeIter)
{
//(*nodeIter)->GetP
}
}
}
}
mitk::DataStorage::Pointer mitk::SceneIO::LoadScene( const std::string& filename,
DataStorage* pStorage,
bool clearStorageFirst )
{
// prepare data storage
DataStorage::Pointer storage = pStorage;
if ( storage.IsNull() )
{
storage = StandaloneDataStorage::New().GetPointer();
}
if ( clearStorageFirst )
{
try
{
storage->Remove( storage->GetAll() );
}
catch(...)
{
MITK_ERROR << "DataStorage cannot be cleared properly.";
}
}
// test input filename
if ( filename.empty() )
{
MITK_ERROR << "No filename given. Not possible to load scene.";
return NULL;
}
// test if filename can be read
std::ifstream file( filename.c_str(), std::ios::binary );
if (!file.good())
{
MITK_ERROR << "Cannot open '" << filename << "' for reading";
return NULL;
}
// get new temporary directory
m_WorkingDirectory = CreateEmptyTempDirectory();
if (m_WorkingDirectory.empty())
{
MITK_ERROR << "Could not create temporary directory. Cannot open scene files.";
return NULL;
}
// unzip all filenames contents to temp dir
m_UnzipErrors = 0;
Poco::Zip::Decompress unzipper( file, Poco::Path( m_WorkingDirectory ) );
unzipper.EError += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string> >(this, &SceneIO::OnUnzipError);
unzipper.EOk += Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path> >(this, &SceneIO::OnUnzipOk);
unzipper.decompressAllFiles();
unzipper.EError -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const std::string> >(this, &SceneIO::OnUnzipError);
unzipper.EOk -= Poco::Delegate<SceneIO, std::pair<const Poco::Zip::ZipLocalFileHeader, const Poco::Path> >(this, &SceneIO::OnUnzipOk);
if ( m_UnzipErrors )
{
MITK_ERROR << "There were " << m_UnzipErrors << " errors unzipping '" << filename << "'. Will attempt to read whatever could be unzipped.";
}
// test if index.xml exists
// parse index.xml with TinyXML
TiXmlDocument document( m_WorkingDirectory + Poco::Path::separator() + "index.xml" );
if (!document.LoadFile())
{
MITK_ERROR << "Could not open/read/parse " << m_WorkingDirectory << "/index.xml\nTinyXML reports: " << document.ErrorDesc() << std::endl;
return NULL;
}
SceneReader::Pointer reader = SceneReader::New();
if ( !reader->LoadScene( document, m_WorkingDirectory, storage ) )
{
MITK_ERROR << "There were errors while loading scene file " << filename << ". Your data may be corrupted";
}
// delete temp directory
try
{
Poco::File deleteDir( m_WorkingDirectory );
deleteDir.remove(true); // recursive
}
catch(...)
{
MITK_ERROR << "Could not delete temporary directory " << m_WorkingDirectory;
}
// return new data storage, even if empty or uncomplete (return as much as possible but notify calling method)
return storage;
}