static
void SaveSliceOrImageAsPNG(mitk::Image::Pointer image, mitk::Image::Pointer mask, std::string path, int index)
{
// Create a Standalone Datastorage for the single purpose of saving screenshots..
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
QmitkRenderWindow renderWindow;
renderWindow.GetRenderer()->SetDataStorage(ds);
auto nodeI = mitk::DataNode::New();
nodeI->SetData(image);
auto nodeM = mitk::DataNode::New();
nodeM->SetData(mask);
ds->Add(nodeI);
ds->Add(nodeM);
auto geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
unsigned int numberOfSteps = 1;
if (sliceNaviController)
{
numberOfSteps = sliceNaviController->GetSlice()->GetSteps();
sliceNaviController->GetSlice()->SetPos(0);
}
renderWindow.show();
renderWindow.resize(256, 256);
for (unsigned int currentStep = 0; currentStep < numberOfSteps; ++currentStep)
{
if (sliceNaviController)
{
sliceNaviController->GetSlice()->SetPos(currentStep);
}
renderWindow.GetRenderer()->PrepareRender();
vtkRenderWindow* renderWindow2 = renderWindow.GetVtkRenderWindow();
mitk::BaseRenderer* baserenderer = mitk::BaseRenderer::GetInstance(renderWindow2);
auto vtkRender = baserenderer->GetVtkRenderer();
vtkRender->GetRenderWindow()->WaitForCompletion();
vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
magnifier->SetInput(vtkRender);
magnifier->SetMagnification(3.0);
std::stringstream ss;
ss << path << "_Idx-" << index << "_Step-"<<currentStep<<".png";
std::string tmpImageName;
ss >> tmpImageName;
auto fileWriter = vtkPNGWriter::New();
fileWriter->SetInputConnection(magnifier->GetOutputPort());
fileWriter->SetFileName(tmpImageName.c_str());
fileWriter->Write();
fileWriter->Delete();
}
}
//##Documentation
//## @brief Load image (nrrd format) and display it in a 2D view
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if (argc < 2)
{
fprintf( stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
// The DataStorage manages all data objects. It is used by the
// rendering mechanism to render all data objects
// We use the standard implementation mitk::StandaloneDataStorage.
mitk::StandaloneDataStorage::Pointer dataStorage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading a file
//*************************************************************************
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
const char * filename = argv[1];
try
{
reader->SetFileName(filename);
reader->Update();
//*************************************************************************
// Part III: Put the data into the datastorage
//*************************************************************************
// Add the node to the DataStorage
dataStorage->Add(reader->GetOutput());
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
//*************************************************************************
// Part IV: Create window and pass the datastorage to it
//*************************************************************************
// Create a RenderWindow
QmitkRenderWindow renderWindow;
// Tell the RenderWindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(dataStorage);
// Initialize the RenderWindow
mitk::TimeSlicedGeometry::Pointer geo = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews( geo );
//mitk::RenderingManager::GetInstance()->InitializeViews();
// Select a slice
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
if (sliceNaviController)
sliceNaviController->GetSlice()->SetPos( 0 );
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
//! [CreateOverlayManager]
mitk::OverlayManager::Pointer OverlayManagerInstance = mitk::OverlayManager::New();
mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetInstance(renderWindow.GetVtkRenderWindow());
renderer->SetOverlayManager(OverlayManagerInstance);
//! [CreateOverlayManager]
//! [GetOverlayManagerInstance]
//The id that is passed identifies the correct mitk::OverlayManager and is '0' by default.
mitk::BaseRenderer* renderer2D = mitk::BaseRenderer::GetInstance(renderWindow.GetVtkRenderWindow());
mitk::OverlayManager::Pointer overlayManager = renderer2D->GetOverlayManager();
//! [GetOverlayManagerInstance]
//! [AddLayouter]
//This creates a 2DLayouter that is only active for the recently fetched axialRenderer and positione
mitk::Overlay2DLayouter::Pointer topleftLayouter = mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D);
//Now, the created Layouter is added to the OverlayManager and can be referred to by its identification string.
overlayManager->AddLayouter(topleftLayouter.GetPointer());
//Several other Layouters can be added to the overlayManager
mitk::Overlay2DLayouter::Pointer bottomLayouter = mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_BOTTOM(), renderer2D);
overlayManager->AddLayouter(bottomLayouter.GetPointer());
//! [AddLayouter]
//! [TextOverlay2D]
//Create a textOverlay2D
mitk::TextOverlay2D::Pointer textOverlay = mitk::TextOverlay2D::New();
textOverlay->SetText("Test!"); //set UTF-8 encoded text to render
textOverlay->SetFontSize(40);
textOverlay->SetColor(1,0,0); //Set text color to red
textOverlay->SetOpacity(1);
//The position of the Overlay can be set to a fixed coordinate on the display.
mitk::Point2D pos;
pos[0] = 10,pos[1] = 20;
textOverlay->SetPosition2D(pos);
//Add the overlay to the overlayManager. It is added to all registered renderers automaticly
overlayManager->AddOverlay(textOverlay.GetPointer());
//Alternatively, a layouter can be used to manage the position of the overlay. If a layouter is set, the absolute position of the overlay is not used anymore
//The Standard TopLeft Layouter has to be registered to the OverlayManager first
overlayManager->AddLayouter(mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(), renderer2D).GetPointer());
//! [TextOverlay2D]
//! [SetLayouterToOverlay]
//Because a Layouter is specified by the identification string AND the Renderer, both have to be passed to the call.
overlayManager->SetLayouter(textOverlay.GetPointer(),mitk::Overlay2DLayouter::STANDARD_2D_TOPLEFT(),renderer2D);
//! [SetLayouterToOverlay]
//! [TextOverlay3D]
mitk::PointSet::Pointer pointset = mitk::PointSet::New();
// This vector is used to define an offset for the annotations, in order to show them with a margin to the actual coordinate.
mitk::Point3D offset;
offset[0] = .5;
offset[1] = .5;
offset[2] = .5;
//Just a loop to create some points
for(int i=0 ; i < 10 ; i++){
//To each point, a TextOverlay3D is created
mitk::TextOverlay3D::Pointer textOverlay3D = mitk::TextOverlay3D::New();
mitk::Point3D point;
point[0] = i*20;
point[1] = i*30;
point[2] = -i*50;
pointset->InsertPoint(i, point);
textOverlay3D->SetText("A Point");
// The Position is set to the point coordinate to create an annotation to the point in the PointSet.
textOverlay3D->SetPosition3D(point);
// move the annotation away from the actual point
textOverlay3D->SetOffsetVector(offset);
overlayManager->AddOverlay(textOverlay3D.GetPointer());
}
// also show the created pointset
mitk::DataNode::Pointer datanode = mitk::DataNode::New();
datanode->SetData(pointset);
datanode->SetName("pointSet");
dataStorage->Add(datanode);
//! [TextOverlay3D]
renderWindow.show();
renderWindow.resize( 256, 256 );
return qtapplication.exec();
// cleanup: Remove References to DataStorage. This will delete the object
dataStorage = NULL;
}
