int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
Step6 mainWidget(argc, argv, nullptr);
mainWidget.Initialize();
mainWidget.show();
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
void org_mitk_gui_qt_application_Activator::start(ctkPluginContext* context)
{
this->m_Context = context;
BERRY_REGISTER_EXTENSION_CLASS(QmitkGeneralPreferencePage, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkEditorsPreferencePage, context)
QmitkRegisterClasses();
}
void org_mitk_gui_qt_application_Activator::start(ctkPluginContext* context)
{
this->m_Context = context;
BERRY_REGISTER_EXTENSION_CLASS(QmitkGeneralPreferencePage, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkEditorsPreferencePage, context)
QFile file(":/org.mitk.gui.qt.common/StateMachine.xml");
if(file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text) )
{
QByteArray contents = file.readAll();
QString string(contents);
file.close();
mitk::GlobalInteraction::GetInstance()->Initialize("global", string.toStdString());
}
else throw std::exception();
QmitkRegisterClasses();
}
void
QmitkCommonActivator::start(ctkPluginContext* context)
{
Q_UNUSED(context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkStdMultiWidgetEditor, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkStdMultiWidgetEditorPreferencePage, context)
QFile file(":/org.mitk.gui.qt.common/StateMachine.xml");
if(file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text) )
{
QByteArray contents = file.readAll();
QString string(contents);
file.close();
mitk::GlobalInteraction::GetInstance()->Initialize("global", string.toStdString());
}
else throw std::exception();
QmitkRegisterClasses();
}
//##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();
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
// Load datanode (eg. many image formats, surface formats, etc.)
mitk::IOUtil::Load(argv[1], *ds);
// Create a RenderWindow
QmitkRenderWindow renderWindow;
// Tell the RenderWindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// Initialize the RenderWindow
auto geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
// mitk::RenderingManager::GetInstance()->InitializeViews();
// Add Overlays
//![TextAnnotation2D]
// Create a textAnnotation2D
mitk::TextAnnotation2D::Pointer textAnnotation = mitk::TextAnnotation2D::New();
textAnnotation->SetText("Test!"); // set UTF-8 encoded text to render
textAnnotation->SetFontSize(40);
textAnnotation->SetColor(1, 0, 0); // Set text color to red
textAnnotation->SetOpacity(1);
// The position of the Annotation can be set to a fixed coordinate on the display.
mitk::Point2D pos;
pos[0] = 10;
pos[1] = 20;
textAnnotation->SetPosition2D(pos);
std::string rendererID = renderWindow.GetRenderer()->GetName();
// The LayoutAnnotationRenderer can place the TextAnnotation2D at some defined corner positions
mitk::LayoutAnnotationRenderer::AddAnnotation(
textAnnotation, rendererID, mitk::LayoutAnnotationRenderer::TopLeft, 5, 5, 1);
//![TextAnnotation2D]
//![TextAnnotation3D]
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;
// save references to Annotations so that they do not get deregistered
std::vector<mitk::TextAnnotation3D::Pointer> annotationReferences;
// Just a loop to create some points
for (unsigned long i = 0; i < 10; i++)
{
// To each point, a TextAnnotation3D is created
mitk::TextAnnotation3D::Pointer textAnnotation3D = mitk::TextAnnotation3D::New();
mitk::Point3D point;
point[0] = i * 20;
point[1] = i * 30;
point[2] = i * -50;
pointset->InsertPoint(i, point);
textAnnotation3D->SetText("A Point");
// The Position is set to the point coordinate to create an annotation to the point in the PointSet.
textAnnotation3D->SetPosition3D(point);
// move the annotation away from the actual point
textAnnotation3D->SetOffsetVector(offset);
annotationReferences.push_back(textAnnotation3D);
mitk::ManualPlacementAnnotationRenderer::AddAnnotation(textAnnotation3D, rendererID);
}
// Get the MicroserviceID of the registered textAnnotation
std::string serviceID = textAnnotation->GetMicroserviceID();
// The AnnotationUtils can retrieve any registered annotations by their microservice ID
mitk::Annotation *annotation = mitk::AnnotationUtils::GetAnnotation(serviceID);
// This way, it is possible to change the properties of Annotations without knowing their implementation
annotation->SetText("changed text!");
// also show the created pointset
mitk::DataNode::Pointer datanode = mitk::DataNode::New();
datanode->SetData(pointset);
datanode->SetName("pointSet");
ds->Add(datanode);
//! [TextAnnotation3D]
renderWindow.show();
renderWindow.resize(256, 256);
renderWindow.show();
renderWindow.resize(256, 256);
// cleanup: Remove References to DataStorage. This will delete the object
ds = nullptr;
}
//##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 ds = 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
ds->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(ds);
// Initialize the RenderWindow
mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->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
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
// for testing
#include "QtTesting.h"
if (strcmp(argv[argc-1], "-testing") != 0)
return qtapplication.exec();
else
return QtTesting();
// cleanup: Remove References to DataStorage. This will delete the object
ds = NULL;
}
//##Documentation
//## @brief Change the type of display to 3D
//##
//## As in Step2, load one or more data sets (many image, surface
//## and other formats), but display it in a 3D view.
//## The QmitkRenderWindow is now used for displaying a 3D view, by
//## setting the used mapper-slot to Standard3D.
//## Since volume-rendering is a (rather) slow procedure, the default
//## is that images are not displayed in the 3D view. For this example,
//## we want volume-rendering, thus we switch it on by setting
//## the Boolean-property "volumerendering" to "true".
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
mitk::StandaloneDataStorage::Pointer ds = 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();
//*********************************************************************
// Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
ds->Add(node);
// *********************************************************
// ****************** START OF NEW PART 1 ******************
// *********************************************************
//*********************************************************************
// Part IV: We want all images to be volume-rendered
//*********************************************************************
// Check if the data is an image by dynamic_cast-ing the data
// contained in the node. Warning: dynamic_cast's are rather slow,
// do not use it too often!
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(true));
// Create a transfer function to assign optical properties (color and opacity) to grey-values of the data
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
tf->InitializeByMitkImage ( image );
// Set the color transfer function AddRGBPoint(double x, double r, double g, double b)
tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [0], 1.0, 0.0, 0.0 );
tf->GetColorTransferFunction()->AddRGBPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1.0, 1.0, 0.0 );
// Set the piecewise opacity transfer function AddPoint(double x, double y)
tf->GetScalarOpacityFunction()->AddPoint ( 0, 0 );
tf->GetScalarOpacityFunction()->AddPoint ( tf->GetColorTransferFunction()->GetRange() [1], 1 );
node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
}
// *********************************************************
// ******************* END OF NEW PART 1 *******************
// *********************************************************
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
}
//*************************************************************************
// Part V: Create window and pass the tree to it
//*************************************************************************
// Create a renderwindow
QmitkRenderWindow renderWindow;
// Tell the renderwindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// *********************************************************
// ****************** START OF NEW PART 2 ******************
// *********************************************************
// Use it as a 3D view!
renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
// *********************************************************
// ******************* END OF NEW PART 2 *******************
// *********************************************************
//*************************************************************************
// Part VI: Qt-specific initialization
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
//##Documentation
//## @brief Use several views to explore data
//##
//## As in Step2 and Step3, load one or more data sets (many image,
//## surface and other formats), but create 3 views on the data.
//## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
//## but without volume-rendering.
//## Furthermore, we create two 2D views for slicing through the data.
//## We use the class QmitkSliceWidget, which is based on the class
//## QmitkRenderWindow, but additionally provides sliders
//## to slice through the data. We create two instances of
//## QmitkSliceWidget, one for axial and one for sagittal slicing.
//## The two slices are also shown at their correct position in 3D as
//## well as intersection-line, each in the other 2D view.
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
mitk::StandaloneDataStorage::Pointer ds = 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();
//*********************************************************************
//Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
ds->Add(node);
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
}
//*************************************************************************
// Part IV: Create windows and pass the tree to it
//*************************************************************************
// Create toplevel widget with horizontal layout
QWidget toplevelWidget;
QHBoxLayout layout;
layout.setSpacing(2);
layout.setMargin(0);
toplevelWidget.setLayout(&layout);
//*************************************************************************
// Part IVa: 3D view
//*************************************************************************
// Create a renderwindow
QmitkRenderWindow renderWindow(&toplevelWidget);
layout.addWidget(&renderWindow);
// Tell the renderwindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// Use it as a 3D view
renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
// *******************************************************
// ****************** START OF NEW PART ******************
// *******************************************************
//*************************************************************************
// Part IVb: 2D view for slicing axially
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget view2(&toplevelWidget);
layout.addWidget(&view2);
view2.SetLevelWindowEnabled(true);
// Tell the QmitkSliceWidget which (part of) the tree to render.
// By default, it slices the data axially
view2.SetDataStorage(ds);
mitk::DataStorage::SetOfObjects::ConstPointer rs = ds->GetAll();
view2.SetData(rs->Begin(),mitk::SliceNavigationController::Axial);
// We want to see the position of the slice in 2D and the
// slice itself in 3D: add it to the datastorage!
ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
//*************************************************************************
// Part IVc: 2D view for slicing sagitally
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget view3(&toplevelWidget);
layout.addWidget(&view3);
view3.SetDataStorage(ds);
// Tell the QmitkSliceWidget which (part of) the datastorage to render
// and to slice sagitally
view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
// We want to see the position of the slice in 2D and the
// slice itself in 3D: add it to the datastorage!
ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
// *******************************************************
// ******************* END OF NEW PART *******************
// *******************************************************
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
toplevelWidget.show();
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
//##Documentation
//## @brief Load one or more data sets (many image, surface
//## and other formats) and display it in a 2D view
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n",
itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a data storage object. We will use it as a singleton
mitk::StandaloneDataStorage::Pointer storage = 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();
//*********************************************************************
// Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
storage->Add(nodeReader->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(storage);
// Initialize the RenderWindow
mitk::TimeGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews( geo );
// Select a slice
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
if (sliceNaviController)
sliceNaviController->GetSlice()->SetPos( 2 );
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
int main(int argc, char* argv[])
{
// Commented : Updated to a common interface, include, if possible, mask is type unsigned short, uses Quantification, Comments
// Name follows standard scheme with Class Name::Feature Name
// Commented 2: Updated to use automatic inclusion of list of parameters if required.
mitk::GIFImageDescriptionFeatures::Pointer ipCalculator = mitk::GIFImageDescriptionFeatures::New(); // Commented 2, Tested
mitk::GIFFirstOrderStatistics::Pointer firstOrderCalculator = mitk::GIFFirstOrderStatistics::New(); //Commented 2
mitk::GIFFirstOrderHistogramStatistics::Pointer firstOrderHistoCalculator = mitk::GIFFirstOrderHistogramStatistics::New(); // Commented 2, Tested
mitk::GIFFirstOrderNumericStatistics::Pointer firstOrderNumericCalculator = mitk::GIFFirstOrderNumericStatistics::New(); // Commented 2, Tested
mitk::GIFVolumetricStatistics::Pointer volCalculator = mitk::GIFVolumetricStatistics::New(); // Commented 2, Tested
mitk::GIFVolumetricDensityStatistics::Pointer voldenCalculator = mitk::GIFVolumetricDensityStatistics::New(); // Commented 2, Tested
mitk::GIFCooccurenceMatrix::Pointer coocCalculator = mitk::GIFCooccurenceMatrix::New(); // Commented 2, Will not be tested
mitk::GIFCooccurenceMatrix2::Pointer cooc2Calculator = mitk::GIFCooccurenceMatrix2::New(); //Commented 2
mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer ngldCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New(); //Commented 2, Tested
mitk::GIFGreyLevelRunLength::Pointer rlCalculator = mitk::GIFGreyLevelRunLength::New(); // Commented 2
mitk::GIFGreyLevelSizeZone::Pointer glszCalculator = mitk::GIFGreyLevelSizeZone::New(); // Commented 2, Tested
mitk::GIFGreyLevelDistanceZone::Pointer gldzCalculator = mitk::GIFGreyLevelDistanceZone::New(); //Commented 2, Tested
mitk::GIFLocalIntensity::Pointer lociCalculator = mitk::GIFLocalIntensity::New(); //Commented 2, Tested
mitk::GIFIntensityVolumeHistogramFeatures::Pointer ivohCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New(); // Commented 2
mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer ngtdCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New(); //Commented 2, Tested
mitk::GIFCurvatureStatistic::Pointer curvCalculator = mitk::GIFCurvatureStatistic::New(); //Commented 2, Tested
std::vector<mitk::AbstractGlobalImageFeature::Pointer> features;
features.push_back(volCalculator.GetPointer());
features.push_back(voldenCalculator.GetPointer());
features.push_back(curvCalculator.GetPointer());
features.push_back(firstOrderCalculator.GetPointer());
features.push_back(firstOrderNumericCalculator.GetPointer());
features.push_back(firstOrderHistoCalculator.GetPointer());
features.push_back(ivohCalculator.GetPointer());
features.push_back(lociCalculator.GetPointer());
features.push_back(coocCalculator.GetPointer());
features.push_back(cooc2Calculator.GetPointer());
features.push_back(ngldCalculator.GetPointer());
features.push_back(rlCalculator.GetPointer());
features.push_back(glszCalculator.GetPointer());
features.push_back(gldzCalculator.GetPointer());
features.push_back(ipCalculator.GetPointer());
features.push_back(ngtdCalculator.GetPointer());
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
mitk::cl::GlobalImageFeaturesParameter param;
param.AddParameter(parser);
parser.addArgument("--","-", mitkCommandLineParser::String, "---", "---", us::Any(),true);
for (auto cFeature : features)
{
cFeature->AddArguments(parser);
}
parser.addArgument("--", "-", mitkCommandLineParser::String, "---", "---", us::Any(), true);
parser.addArgument("description","d",mitkCommandLineParser::String,"Text","Description that is added to the output",us::Any());
parser.addArgument("direction", "dir", mitkCommandLineParser::String, "Int", "Allows to specify the direction for Cooc and RL. 0: All directions, 1: Only single direction (Test purpose), 2,3,4... Without dimension 0,1,2... ", us::Any());
parser.addArgument("slice-wise", "slice", mitkCommandLineParser::String, "Int", "Allows to specify if the image is processed slice-wise (number giving direction) ", us::Any());
parser.addArgument("output-mode", "omode", mitkCommandLineParser::Int, "Int", "Defines if the results of an image / slice are written in a single row (0 , default) or column (1).");
// Miniapp Infos
parser.setCategory("Classification Tools");
parser.setTitle("Global Image Feature calculator");
parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
parser.setContributor("MBI");
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
param.ParseParameter(parsedArgs);
if (parsedArgs.size()==0)
{
return EXIT_FAILURE;
}
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
return EXIT_SUCCESS;
}
//bool savePNGofSlices = true;
//std::string folderForPNGOfSlices = "E:\\tmp\\bonekamp\\fig\\";
std::string version = "Version: 1.22";
MITK_INFO << version;
std::ofstream log;
if (param.useLogfile)
{
log.open(param.logfilePath, std::ios::app);
log << std::endl;
log << version;
log << "Image: " << param.imagePath;
log << "Mask: " << param.maskPath;
}
if (param.useDecimalPoint)
{
std::cout.imbue(std::locale(std::cout.getloc(), new punct_facet<char>(param.decimalPoint)));
}
mitk::Image::Pointer image;
mitk::Image::Pointer mask;
mitk::Image::Pointer tmpImage = mitk::IOUtil::Load<mitk::Image>(param.imagePath);
mitk::Image::Pointer tmpMask = mitk::IOUtil::Load<mitk::Image>(param.maskPath);
image = tmpImage;
mask = tmpMask;
mitk::Image::Pointer morphMask = mask;
if (param.useMorphMask)
{
morphMask = mitk::IOUtil::Load<mitk::Image>(param.morphPath);
}
log << " Check for Dimensions -";
if ((image->GetDimension() != mask->GetDimension()))
{
MITK_INFO << "Dimension of image does not match. ";
MITK_INFO << "Correct one image, may affect the result";
if (image->GetDimension() == 2)
{
mitk::Convert2Dto3DImageFilter::Pointer multiFilter2 = mitk::Convert2Dto3DImageFilter::New();
multiFilter2->SetInput(tmpImage);
multiFilter2->Update();
image = multiFilter2->GetOutput();
}
if (mask->GetDimension() == 2)
{
mitk::Convert2Dto3DImageFilter::Pointer multiFilter3 = mitk::Convert2Dto3DImageFilter::New();
multiFilter3->SetInput(tmpMask);
multiFilter3->Update();
mask = multiFilter3->GetOutput();
}
}
int writeDirection = 0;
if (parsedArgs.count("output-mode"))
{
writeDirection = us::any_cast<int>(parsedArgs["output-mode"]);
}
log << " Check for Resolution -";
if (param.resampleToFixIsotropic)
{
mitk::Image::Pointer newImage = mitk::Image::New();
AccessByItk_2(image, ResampleImage, param.resampleResolution, newImage);
image = newImage;
}
if ( ! mitk::Equal(mask->GetGeometry(0)->GetOrigin(), image->GetGeometry(0)->GetOrigin()))
{
MITK_INFO << "Not equal Origins";
if (param.ensureSameSpace)
{
MITK_INFO << "Warning!";
MITK_INFO << "The origin of the input image and the mask do not match. They are";
MITK_INFO << "now corrected. Please check to make sure that the images still match";
image->GetGeometry(0)->SetOrigin(mask->GetGeometry(0)->GetOrigin());
} else
{
return -1;
}
}
log << " Resample if required -";
if (param.resampleMask)
{
mitk::Image::Pointer newMaskImage = mitk::Image::New();
AccessByItk_2(mask, ResampleMask, image, newMaskImage);
mask = newMaskImage;
}
log << " Check for Equality -";
if ( ! mitk::Equal(mask->GetGeometry(0)->GetSpacing(), image->GetGeometry(0)->GetSpacing()))
{
MITK_INFO << "Not equal Spacing";
if (param.ensureSameSpace)
{
MITK_INFO << "Warning!";
MITK_INFO << "The spacing of the mask was set to match the spacing of the input image.";
MITK_INFO << "This might cause unintended spacing of the mask image";
image->GetGeometry(0)->SetSpacing(mask->GetGeometry(0)->GetSpacing());
} else
{
MITK_INFO << "The spacing of the mask and the input images is not equal.";
MITK_INFO << "Terminating the programm. You may use the '-fi' option";
return -1;
}
}
int direction = 0;
if (parsedArgs.count("direction"))
{
direction = mitk::cl::splitDouble(parsedArgs["direction"].ToString(), ';')[0];
}
MITK_INFO << "Start creating Mask without NaN";
mitk::Image::Pointer maskNoNaN = mitk::Image::New();
AccessByItk_2(image, CreateNoNaNMask, mask, maskNoNaN);
//CreateNoNaNMask(mask, image, maskNoNaN);
bool sliceWise = false;
int sliceDirection = 0;
unsigned int currentSlice = 0;
bool imageToProcess = true;
std::vector<mitk::Image::Pointer> floatVector;
std::vector<mitk::Image::Pointer> maskVector;
std::vector<mitk::Image::Pointer> maskNoNaNVector;
std::vector<mitk::Image::Pointer> morphMaskVector;
if ((parsedArgs.count("slice-wise")) && image->GetDimension() > 2)
{
MITK_INFO << "Enabled slice-wise";
sliceWise = true;
sliceDirection = mitk::cl::splitDouble(parsedArgs["slice-wise"].ToString(), ';')[0];
MITK_INFO << sliceDirection;
ExtractSlicesFromImages(image, mask, maskNoNaN, morphMask, sliceDirection, floatVector, maskVector, maskNoNaNVector, morphMaskVector);
MITK_INFO << "Slice";
}
log << " Configure features -";
for (auto cFeature : features)
{
if (param.defineGlobalMinimumIntensity)
{
cFeature->SetMinimumIntensity(param.globalMinimumIntensity);
cFeature->SetUseMinimumIntensity(true);
}
if (param.defineGlobalMaximumIntensity)
{
cFeature->SetMaximumIntensity(param.globalMaximumIntensity);
cFeature->SetUseMaximumIntensity(true);
}
if (param.defineGlobalNumberOfBins)
{
cFeature->SetBins(param.globalNumberOfBins);
MITK_INFO << param.globalNumberOfBins;
}
cFeature->SetParameter(parsedArgs);
cFeature->SetDirection(direction);
cFeature->SetEncodeParameters(param.encodeParameter);
}
bool addDescription = parsedArgs.count("description");
mitk::cl::FeatureResultWritter writer(param.outputPath, writeDirection);
if (param.useDecimalPoint)
{
writer.SetDecimalPoint(param.decimalPoint);
}
std::string description = "";
if (addDescription)
{
description = parsedArgs["description"].ToString();
}
mitk::Image::Pointer cImage = image;
mitk::Image::Pointer cMask = mask;
mitk::Image::Pointer cMaskNoNaN = maskNoNaN;
mitk::Image::Pointer cMorphMask = morphMask;
if (param.useHeader)
{
writer.AddColumn("SoftwareVersion");
writer.AddColumn("Patient");
writer.AddColumn("Image");
writer.AddColumn("Segmentation");
}
// Create a QTApplication and a Datastorage
// This is necessary in order to save screenshots of
// each image / slice.
QApplication qtapplication(argc, argv);
QmitkRegisterClasses();
std::vector<mitk::AbstractGlobalImageFeature::FeatureListType> allStats;
log << " Begin Processing -";
while (imageToProcess)
{
if (sliceWise)
{
cImage = floatVector[currentSlice];
cMask = maskVector[currentSlice];
cMaskNoNaN = maskNoNaNVector[currentSlice];
cMorphMask = morphMaskVector[currentSlice];
imageToProcess = (floatVector.size()-1 > (currentSlice)) ? true : false ;
}
else
{
imageToProcess = false;
}
if (param.writePNGScreenshots)
{
SaveSliceOrImageAsPNG(cImage, cMask, param.pngScreenshotsPath, currentSlice);
}
if (param.writeAnalysisImage)
{
mitk::IOUtil::Save(cImage, param.anaylsisImagePath);
}
if (param.writeAnalysisMask)
{
mitk::IOUtil::Save(cMask, param.analysisMaskPath);
}
mitk::AbstractGlobalImageFeature::FeatureListType stats;
for (auto cFeature : features)
{
log << " Calculating " << cFeature->GetFeatureClassName() << " -";
cFeature->SetMorphMask(cMorphMask);
cFeature->CalculateFeaturesUsingParameters(cImage, cMask, cMaskNoNaN, stats);
}
for (std::size_t i = 0; i < stats.size(); ++i)
{
std::cout << stats[i].first << " - " << stats[i].second << std::endl;
}
writer.AddHeader(description, currentSlice, stats, param.useHeader, addDescription);
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName);
}
writer.AddResult(description, currentSlice, stats, param.useHeader, addDescription);
allStats.push_back(stats);
++currentSlice;
}
log << " Process Slicewise -";
if (sliceWise)
{
mitk::AbstractGlobalImageFeature::FeatureListType statMean, statStd;
for (std::size_t i = 0; i < allStats[0].size(); ++i)
{
auto cElement1 = allStats[0][i];
cElement1.first = "SliceWise Mean " + cElement1.first;
cElement1.second = 0.0;
auto cElement2 = allStats[0][i];
cElement2.first = "SliceWise Var. " + cElement2.first;
cElement2.second = 0.0;
statMean.push_back(cElement1);
statStd.push_back(cElement2);
}
for (auto cStat : allStats)
{
for (std::size_t i = 0; i < cStat.size(); ++i)
{
statMean[i].second += cStat[i].second / (1.0*allStats.size());
}
}
for (auto cStat : allStats)
{
for (std::size_t i = 0; i < cStat.size(); ++i)
{
statStd[i].second += (cStat[i].second - statMean[i].second)*(cStat[i].second - statMean[i].second) / (1.0*allStats.size());
}
}
for (std::size_t i = 0; i < statMean.size(); ++i)
{
std::cout << statMean[i].first << " - " << statMean[i].second << std::endl;
std::cout << statStd[i].first << " - " << statStd[i].second << std::endl;
}
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName + " - Mean");
}
writer.AddResult(description, currentSlice, statMean, param.useHeader, addDescription);
if (true)
{
writer.AddSubjectInformation(MITK_REVISION);
writer.AddSubjectInformation(param.imageFolder);
writer.AddSubjectInformation(param.imageName);
writer.AddSubjectInformation(param.maskName + " - Var.");
}
writer.AddResult(description, currentSlice, statStd, param.useHeader, addDescription);
}
if (param.useLogfile)
{
log << "Finished calculation" << std::endl;
log.close();
}
return 0;
}
//##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;
}
