void QmitkDataStorageTableModel::SetDataStorage( mitk::DataStorage::Pointer _DataStorage )
{
// only proceed if we have a new datastorage
if(m_DataStorage.GetPointer() != _DataStorage.GetPointer())
{
// if a data storage was set before remove old event listeners
if(m_DataStorage.IsNotNull())
{
this->m_DataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTableModel
, const mitk::DataNode*>( this, &QmitkDataStorageTableModel::AddNode ) );
this->m_DataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTableModel
, const mitk::DataNode*>( this, &QmitkDataStorageTableModel::RemoveNode ) );
}
// set new data storage
m_DataStorage = _DataStorage.GetPointer();
// if new storage is not 0 subscribe for events
if(m_DataStorage.IsNotNull())
{
// subscribe for node added/removed events
this->m_DataStorage->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTableModel
, const mitk::DataNode*>( this, &QmitkDataStorageTableModel::AddNode ) );
this->m_DataStorage->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTableModel
, const mitk::DataNode*>( this, &QmitkDataStorageTableModel::RemoveNode ) );
}
// Reset model (even if datastorage is 0->will be checked in Reset())
this->Reset();
}
}
void AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
float white[3] = {1.0f, 1.0f, 1.0f};
mitk::PlaneGeometryDataMapper2D::Pointer mapper;
mitk::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
// ... of widget 1
m_PlaneNode1 =
(mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("layer", layer);
m_PlaneNode1->SetColor(1.0, 0.0, 0.0);
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
m_PlaneNode2 =
(mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("layer", layer);
m_PlaneNode2->SetColor(0.0, 1.0, 0.0);
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
m_PlaneNode3 =
(mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow()))->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("layer", layer);
m_PlaneNode3->SetColor(0.0, 0.0, 1.0);
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// AddPlanesToDataStorage
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_PlaneNode1);
m_DataStorage->Add(m_PlaneNode2);
m_DataStorage->Add(m_PlaneNode3);
}
}
}
static void InitializeViews(mitk::DataStorage::Pointer dataStorage)
{
mitk::NodePredicateNot::Pointer predicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer subset = dataStorage->GetSubset(predicate);
mitk::TimeSlicedGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(subset);
mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
fprintf(stderr, "Usage: %s [filename1] [filename2] ...\n\n", "");
return 1;
}
// Create a DataStorage
m_DataStorage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for (i = 1; i < argc; ++i)
{
// For testing
if (strcmp(argv[i], "-testing") == 0)
continue;
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
const char * filename = argv[i];
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
m_DataStorage->Add(node);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if (image.IsNotNull())
{
// Set the property "volumerendering" to the Boolean value "true"
node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
node->SetProperty("name", mitk::StringProperty::New("testimage"));
node->SetProperty("layer", mitk::IntProperty::New(1));
}
} catch (...)
{
fprintf(stderr, "Could not open file %s \n\n", filename);
exit(2);
}
}
//*************************************************************************
// Part V: Create window and pass the tree to it
//*************************************************************************
// Global Interaction initialize
// legacy because window manager relies still on existence if global interaction
mitk::GlobalInteraction::GetInstance()->Initialize("global");
//mitk::GlobalInteraction::GetInstance()->AddListener(m_DisplayInteractor);
// Create renderwindows
mitkWidget1 = mitk::RenderWindow::New();
mitkWidget2 = mitk::RenderWindow::New();
mitkWidget3 = mitk::RenderWindow::New();
mitkWidget4 = mitk::RenderWindow::New();
// Tell the renderwindow which (part of) the datastorage to render
mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
gi->AddListener(mitkWidget1->GetSliceNavigationController());
gi->AddListener(mitkWidget2->GetSliceNavigationController());
gi->AddListener(mitkWidget3->GetSliceNavigationController());
gi->AddListener(mitkWidget4->GetSliceNavigationController());
// instantiate display interactor
if (m_DisplayInteractor.IsNull())
{
m_DisplayInteractor = mitk::DisplayInteractor::New();
m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
m_DisplayInteractor->SetEventConfig("DisplayConfigMITK.xml");
// Register as listener via micro services
us::ModuleContext* context = us::GetModuleContext();
context->RegisterService<mitk::InteractionEventObserver>(
m_DisplayInteractor.GetPointer());
}
// Use it as a 2D View
mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
mitkWidget1->SetSize(400, 400);
mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
mitkWidget2->SetSize(400, 400);
mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget3->SetSize(400, 400);
mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget4->SetSize(400, 400);
InitializeWindows();
AddDisplayPlaneSubTree();
Fit();
// Initialize the RenderWindows
mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
m_DataStorage->Print(std::cout);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// reinit the mitkVTKEventProvider;
// this is only necessary once after calling
// ForceImmediateUpdateAll() for the first time
mitkWidget1->ReinitEventProvider();
mitkWidget2->ReinitEventProvider();
mitkWidget3->ReinitEventProvider();
mitkWidget1->GetVtkRenderWindow()->Render();
mitkWidget2->GetVtkRenderWindow()->Render();
mitkWidget3->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindowInteractor()->Start();
return 0;
}
bool MRFRegistration2DParametersWidget::initialise(mitk::DataStorage::Pointer storage)
{
// Populate the combo boxes with the data
//
//
//
mitk::DataStorage::SetOfObjects::ConstPointer images = storage->GetAll();
for(unsigned int i = 0; i < images->size(); i++)
{
// check that the item is an image
mitk::Image::Pointer image = mitk::Image::New();
image = dynamic_cast<mitk::Image*>(images->GetElement(i)->GetData());
if(image)
{
// now break out the slices and times steps
int timeSteps = image->GetTimeSteps();
for(int t = 0; t < timeSteps; t++)
{
// now break out the z slices
int zdims = image->GetDimension(2);
for(int z = 0; z < zdims; z++)
{
// we now need to split them up so as to access the
// 2d slices
//
//
//
mitk::ImageSliceSelector::Pointer timeImageSelector = mitk::ImageSliceSelector::New();
timeImageSelector->SetInput(image);
timeImageSelector->SetTimeNr(t);
timeImageSelector->SetSliceNr(z);
try
{
timeImageSelector->Update();
}
catch(mitk::Exception &e)
{
std::cout << "Error in extracting a slice" << std::endl;
std::cout << e << std::endl;
break;
}
mitk::Image::Pointer imageSlice = timeImageSelector->GetOutput();
imageSlice->SetGeometry(image->GetGeometry(0));
imageSlice->Update();
imageHolder.push_back(imageSlice);
// add an entry into the combo boxes
//
//
//
QString entryName = QString::fromStdString(images->GetElement(i)->GetName()) + " z: " + QString::number(z) + " t: " + QString::number(t);
this->fixedImageSelector->addItem(entryName);
this->movingImageSelector->addItem(entryName);
}
}
}
}
// connect up all the buttons
connect(this->makeGridButton, SIGNAL(pressed()), this, SLOT(updateGridImage()));
connect(this->linkDisplacementToGrid, SIGNAL(pressed()), this, SLOT(setMaxDisplacementToGrid()));
connect(this->resetParamsButton, SIGNAL(pressed()), this, SLOT(resetParams()));
connect(this->startRegistrationButton, SIGNAL(pressed()), this, SLOT(startRegistration()));
return true;
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
fprintf(stderr, "Usage: %s [filename1] [filename2] ...\n\n", "");
return 1;
}
// Create a DataStorage
m_DataStorage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for (i = 1; i < argc; ++i)
{
// For testing
if (strcmp(argv[i], "-testing") == 0)
continue;
std::string filename = argv[i];
try
{
// Read the file and add it as a data node to the data storage
mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::IOUtil::Load(filename, *m_DataStorage);
for (mitk::DataStorage::SetOfObjects::Iterator nodeIter = nodes->Begin(),
nodeIterEnd = nodes->End(); nodeIter != nodeIterEnd; ++nodeIter)
{
mitk::DataNode::Pointer node = nodeIter->Value();
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if (image.IsNotNull())
{
// Set the property "volumerendering" to the Boolean value "true"
node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
node->SetProperty("name", mitk::StringProperty::New("testimage"));
node->SetProperty("layer", mitk::IntProperty::New(1));
}
}
} catch (...)
{
std::cerr << "Could not open file " << filename << std::endl;
exit(2);
}
}
//*************************************************************************
// Part V: Create window and pass the tree to it
//*************************************************************************
// Create renderwindows
mitkWidget1 = mitk::RenderWindow::New();
mitkWidget2 = mitk::RenderWindow::New();
mitkWidget3 = mitk::RenderWindow::New();
mitkWidget4 = mitk::RenderWindow::New();
mitkWidget1->GetRenderer()->PrepareRender();
mitkWidget2->GetRenderer()->PrepareRender();
mitkWidget3->GetRenderer()->PrepareRender();
// Tell the renderwindow which (part of) the datastorage to render
mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
// instantiate display interactor
if (m_DisplayInteractor.IsNull())
{
m_DisplayInteractor = mitk::DisplayInteractor::New();
m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
m_DisplayInteractor->SetEventConfig("DisplayConfigMITK.xml");
// Register as listener via micro services
us::ModuleContext* context = us::GetModuleContext();
context->RegisterService<mitk::InteractionEventObserver>(
m_DisplayInteractor.GetPointer());
}
// Use it as a 2D View
mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
mitkWidget1->SetSize(400, 400);
mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
mitkWidget2->SetSize(400, 400);
mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget3->SetSize(400, 400);
mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget4->SetSize(400, 400);
InitializeWindows();
AddDisplayPlaneSubTree();
Fit();
// Initialize the RenderWindows
mitk::TimeGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
m_DataStorage->Print(std::cout);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// reinit the mitkVTKEventProvider;
// this is only necessary once after calling
// ForceImmediateUpdateAll() for the first time
mitkWidget1->ReinitEventProvider();
mitkWidget2->ReinitEventProvider();
mitkWidget3->ReinitEventProvider();
mitkWidget1->GetVtkRenderWindow()->Render();
mitkWidget2->GetVtkRenderWindow()->Render();
mitkWidget3->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindowInteractor()->Start();
return 0;
}
void Run(berry::IWorkbenchPartSite::Pointer workbenchPartSite, mitk::DataStorage::Pointer dataStorage, const QList<mitk::DataNode::Pointer>& selectedNodes /*= QList<mitk::DataNode::Pointer>()*/, mitk::BaseRenderer* baseRenderer /*= nullptr*/)
{
if (selectedNodes.empty())
{
return;
}
auto renderWindow = mitk::WorkbenchUtil::GetRenderWindowPart(workbenchPartSite->GetPage(), mitk::WorkbenchUtil::NONE);
if (nullptr == renderWindow)
{
renderWindow = mitk::WorkbenchUtil::OpenRenderWindowPart(workbenchPartSite->GetPage(), false);
if (nullptr == renderWindow)
{
// no render window available
return;
}
}
auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New();
for (const auto& dataNode : selectedNodes)
{
if (boundingBoxPredicate->CheckNode(dataNode))
{
nodes->InsertElement(nodes->Size(), dataNode);
}
}
if (nodes->empty())
{
return;
}
if (1 == nodes->Size()) // Special case: If exactly one ...
{
auto image = dynamic_cast<mitk::Image*>(nodes->ElementAt(0)->GetData());
if (nullptr != image) // ... image is selected, reinit is expected to rectify askew images.
{
if (nullptr == baseRenderer)
{
mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
else
{
mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), image->GetTimeGeometry(), true);
}
return;
}
}
auto boundingGeometry = dataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer);
if (nullptr == baseRenderer)
{
mitk::RenderingManager::GetInstance()->InitializeViews(boundingGeometry);
}
else
{
mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry);
}
}
