#include <Step6.h>
Public Member Functions | |
| Step6 (int argc, char *argv[], QWidget *parent=0) | |
| Start region-grower at interactively added points. | |
| ~Step6 () | |
| virtual void | Initialize () |
| virtual int | GetThresholdMin () |
| virtual int | GetThresholdMax () |
Protected Slots | |
| virtual void | StartRegionGrowing () |
Protected Member Functions | |
| void | Load (int argc, char *argv[]) |
| virtual void | SetupWidgets () |
Protected Attributes | |
| mitk::StandaloneDataStorage::Pointer | m_DataStorage |
| mitk::Image::Pointer | m_FirstImage |
| mitk::PointSet::Pointer | m_Seeds |
| mitk::Image::Pointer | m_ResultImage |
| mitk::DataNode::Pointer | m_ResultNode |
| QLineEdit * | m_LineEditThresholdMin |
| QLineEdit * | m_LineEditThresholdMax |
Friends | |
| template<typename TPixel , unsigned int VImageDimension> | |
| void | RegionGrowing (itk::Image< TPixel, VImageDimension > *itkImage, Step6 *step6) |
Step6.h, Step6main.cpp, Step6RegionGrowing.txx, Step6RegionGrowing1.cpp, Step6RegionGrowing2.cpp, Step7.cpp, Step7.h, Step8.cpp, and Step8.h.
Definition at line 33 of file Step6.h.
| Step6::Step6 | ( | int | argc, |
| char * | argv[], | ||
| QWidget * | parent = 0 |
||
| ) |
Start region-grower at interactively added points.
Definition at line 44 of file Step6.cpp.
References Load().
: QWidget(parent)
{
// load data as in the previous steps; a reference to the first loaded
// image is kept in the member m_FirstImage and used as input for the
// region growing
Load(argc, argv);
}
| int Step6::GetThresholdMax | ( | ) | [virtual] |
Definition at line 104 of file Step6.cpp.
References m_LineEditThresholdMax.
Referenced by RegionGrowing().
{
return m_LineEditThresholdMax->text().toInt();
}
| int Step6::GetThresholdMin | ( | ) | [virtual] |
Definition at line 99 of file Step6.cpp.
References m_LineEditThresholdMin.
Referenced by RegionGrowing().
{
return m_LineEditThresholdMin->text().toInt();
}
| void Step6::Initialize | ( | ) | [virtual] |
Definition at line 53 of file Step6.cpp.
References mitk::GlobalInteraction::GetInstance(), m_DataStorage, m_FirstImage, m_LineEditThresholdMax, m_LineEditThresholdMin, m_Seeds, mitk::PointSetInteractor::New(), mitk::IntProperty::New(), mitk::DataNode::New(), mitk::PointSet::New(), SetupWidgets(), and StartRegionGrowing().
Referenced by main().
{
// setup the widgets as in the previous steps, but with an additional
// QVBox for a button to start the segmentation
this->SetupWidgets();
// Create controlsParent widget with horizontal layout
QWidget *controlsParent = new QWidget(this);
this->layout()->addWidget(controlsParent);
QHBoxLayout* hlayout = new QHBoxLayout(controlsParent);
hlayout->setSpacing(2);
QLabel *labelThresholdMin = new QLabel("Lower Threshold:", controlsParent);
hlayout->addWidget(labelThresholdMin);
m_LineEditThresholdMin = new QLineEdit("-1000", controlsParent);
hlayout->addWidget(m_LineEditThresholdMin);
QLabel *labelThresholdMax = new QLabel("Upper Threshold:", controlsParent);
hlayout->addWidget(labelThresholdMax);
m_LineEditThresholdMax = new QLineEdit("-400", controlsParent);
hlayout->addWidget(m_LineEditThresholdMax);
// create button to start the segmentation and connect its clicked()
// signal to method StartRegionGrowing
QPushButton* startButton = new QPushButton("start region growing",
controlsParent);
hlayout->addWidget(startButton);
connect(startButton, SIGNAL(clicked()), this, SLOT(StartRegionGrowing()));
if (m_FirstImage.IsNull())
startButton->setEnabled(false);
// as in Step5, create PointSet (now as a member m_Seeds) and
// associate a interactor to it
m_Seeds = mitk::PointSet::New();
mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
pointSetNode->SetData(m_Seeds);
pointSetNode->SetProperty("layer", mitk::IntProperty::New(2));
m_DataStorage->Add(pointSetNode);
mitk::GlobalInteraction::GetInstance()->AddInteractor(
mitk::PointSetInteractor::New("pointsetinteractor", pointSetNode));
}
| void Step6::Load | ( | int | argc, |
| char * | argv[] | ||
| ) | [protected] |
Definition at line 116 of file Step6.cpp.
References m_DataStorage, m_FirstImage, mitk::DataNodeFactory::New(), and mitk::StandaloneDataStorage::New().
Referenced by Step6().
{
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
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();
//*********************************************************************
// Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the iterator to add the read node to the tree
mitk::DataNode::Pointer node = nodeReader->GetOutput();
m_DataStorage->Add(node);
mitk::Image::Pointer image =
dynamic_cast<mitk::Image*> (node->GetData());
if ((m_FirstImage.IsNull()) && (image.IsNotNull()))
m_FirstImage = image;
} catch (...)
{
fprintf(stderr, "Could not open file %s \n\n", filename);
exit(2);
}
}
}
| void Step6::SetupWidgets | ( | ) | [protected, virtual] |
Reimplemented in Step8.
Definition at line 164 of file Step6.cpp.
References mitk::BaseRenderer::GetCurrentWorldGeometry2DNode(), QmitkSliceWidget::GetRenderer(), mitk::RenderWindowBase::GetRenderer(), m_DataStorage, mitk::SliceNavigationController::Sagittal, QmitkSliceWidget::SetData(), QmitkSliceWidget::SetDataStorage(), mitk::VtkPropRenderer::SetDataStorage(), mitk::VtkPropRenderer::SetMapperID(), mitk::BaseRenderer::Standard3D, and mitk::SliceNavigationController::Transversal.
Referenced by Initialize().
{
//*************************************************************************
// Part I: Create windows and pass the datastorage to it
//*************************************************************************
// Create toplevel widget with vertical layout
QVBoxLayout* vlayout = new QVBoxLayout(this);
vlayout->setMargin(0);
vlayout->setSpacing(2);
// Create viewParent widget with horizontal layout
QWidget* viewParent = new QWidget(this);
vlayout->addWidget(viewParent);
QHBoxLayout* hlayout = new QHBoxLayout(viewParent);
hlayout->setMargin(0);
hlayout->setSpacing(2);
//*************************************************************************
// Part Ia: 3D view
//*************************************************************************
// Create a renderwindow
QmitkRenderWindow* renderWindow = new QmitkRenderWindow(viewParent);
hlayout->addWidget(renderWindow);
// Tell the renderwindow which (part of) the tree to render
renderWindow->GetRenderer()->SetDataStorage(m_DataStorage);
// Use it as a 3D view
renderWindow->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
//*************************************************************************
// Part Ib: 2D view for slicing transversally
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget *view2 = new QmitkSliceWidget(viewParent);
hlayout->addWidget(view2);
// Tell the QmitkSliceWidget which (part of) the tree to render.
// By default, it slices the data transversally
view2->SetDataStorage(m_DataStorage);
mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
view2->SetData(rs->Begin(), mitk::SliceNavigationController::Transversal);
// We want to see the position of the slice in 2D and the
// slice itself in 3D: add it to the tree!
m_DataStorage->Add(view2->GetRenderer()->GetCurrentWorldGeometry2DNode());
//*************************************************************************
// Part Ic: 2D view for slicing sagitally
//*************************************************************************
// Create QmitkSliceWidget, which is based on the class
// QmitkRenderWindow, but additionally provides sliders
QmitkSliceWidget *view3 = new QmitkSliceWidget(viewParent);
hlayout->addWidget(view3);
// Tell the QmitkSliceWidget which (part of) the tree to render
// and to slice sagitally
view3->SetDataStorage(m_DataStorage);
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 tree!
m_DataStorage->Add(view3->GetRenderer()->GetCurrentWorldGeometry2DNode());
//*************************************************************************
// Part II: handle updates: To avoid unnecessary updates, we have to
//*************************************************************************
// define when to update. The RenderingManager serves this purpose, and
// each RenderWindow has to be registered to it.
/*mitk::RenderingManager *renderingManager =
mitk::RenderingManager::GetInstance();
renderingManager->AddRenderWindow( renderWindow );
renderingManager->AddRenderWindow( view2->GetRenderWindow() );
renderingManager->AddRenderWindow( view3->GetRenderWindow() );*/
}
| void Step6::StartRegionGrowing | ( | ) | [protected, virtual, slot] |
Reimplemented in Step7.
Definition at line 109 of file Step6.cpp.
References AccessByItk_1, mitk::RenderingManager::GetInstance(), m_FirstImage, and RegionGrowing.
Referenced by Initialize().
{
AccessByItk_1(m_FirstImage, RegionGrowing, this);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
| void RegionGrowing | ( | itk::Image< TPixel, VImageDimension > * | itkImage, |
| Step6 * | step6 | ||
| ) | [friend] |
Definition at line 13 of file Step6RegionGrowing.txx.
Referenced by StartRegionGrowing().
{
typedef itk::Image< TPixel, VImageDimension > ImageType;
typedef float InternalPixelType;
typedef itk::Image< InternalPixelType, VImageDimension > InternalImageType;
mitk::Geometry3D* geometry = step6->m_FirstImage->GetGeometry();
// create itk::CurvatureFlowImageFilter for smoothing and set itkImage as input
typedef itk::CurvatureFlowImageFilter< ImageType, InternalImageType >
CurvatureFlowFilter;
typename CurvatureFlowFilter::Pointer smoothingFilter = CurvatureFlowFilter::New();
smoothingFilter->SetInput( itkImage );
smoothingFilter->SetNumberOfIterations( 4 );
smoothingFilter->SetTimeStep( 0.0625 );
// create itk::ConnectedThresholdImageFilter and set filtered image as input
typedef itk::ConnectedThresholdImageFilter< InternalImageType, ImageType > RegionGrowingFilterType;
typedef typename RegionGrowingFilterType::IndexType IndexType;
typename RegionGrowingFilterType::Pointer regGrowFilter = RegionGrowingFilterType::New();
regGrowFilter->SetInput( smoothingFilter->GetOutput() );
regGrowFilter->SetLower( step6->GetThresholdMin() );
regGrowFilter->SetUpper( step6->GetThresholdMax() );
// convert the points in the PointSet m_Seeds (in world-coordinates) to
// "index" values, i.e. points in pixel coordinates, and add these as seeds
// to the RegionGrower
mitk::PointSet::PointsConstIterator pit, pend = step6->m_Seeds->GetPointSet()->GetPoints()->End();
IndexType seedIndex;
for (pit = step6->m_Seeds->GetPointSet()->GetPoints()->Begin(); pit != pend; ++pit)
{
geometry->WorldToIndex(pit.Value(), seedIndex);
regGrowFilter->AddSeed( seedIndex );
}
regGrowFilter->GetOutput()->Update();
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::CastToMitkImage(regGrowFilter->GetOutput(), mitkImage);
if (step6->m_ResultNode.IsNull())
{
step6->m_ResultNode = mitk::DataNode::New();
step6->m_DataStorage->Add(step6->m_ResultNode);
}
step6->m_ResultNode->SetData(mitkImage);
// set some additional properties
step6->m_ResultNode->SetProperty("name", mitk::StringProperty::New("segmentation"));
step6->m_ResultNode->SetProperty("binary", mitk::BoolProperty::New(true));
step6->m_ResultNode->SetProperty("color", mitk::ColorProperty::New(1.0,0.0,0.0));
step6->m_ResultNode->SetProperty("volumerendering", mitk::BoolProperty::New(true));
step6->m_ResultNode->SetProperty("layer", mitk::IntProperty::New(1));
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( mitkImage );
levWinProp->SetLevelWindow( levelwindow );
step6->m_ResultNode->SetProperty( "levelwindow", levWinProp );
step6->m_ResultImage = static_cast<mitk::Image*>(step6->m_ResultNode->GetData());
}
Definition at line 52 of file Step6.h.
Referenced by Initialize(), Load(), RegionGrowing(), Step8::SetupWidgets(), SetupWidgets(), and Step7::StartRegionGrowing().
mitk::Image::Pointer Step6::m_FirstImage [protected] |
Definition at line 53 of file Step6.h.
Referenced by Initialize(), Load(), RegionGrowing(), and StartRegionGrowing().
QLineEdit* Step6::m_LineEditThresholdMax [protected] |
Definition at line 60 of file Step6.h.
Referenced by GetThresholdMax(), and Initialize().
QLineEdit* Step6::m_LineEditThresholdMin [protected] |
Definition at line 59 of file Step6.h.
Referenced by GetThresholdMin(), and Initialize().
mitk::Image::Pointer Step6::m_ResultImage [protected] |
Definition at line 56 of file Step6.h.
Referenced by RegionGrowing(), and Step7::StartRegionGrowing().
mitk::DataNode::Pointer Step6::m_ResultNode [protected] |
Definition at line 57 of file Step6.h.
Referenced by RegionGrowing(), and Step7::StartRegionGrowing().
mitk::PointSet::Pointer Step6::m_Seeds [protected] |
Definition at line 54 of file Step6.h.
Referenced by Initialize(), and RegionGrowing().
1.7.2