void mitk::RegionGrow3DTool::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
if ( !imageGeometry->IsInside(seedPoint) )
{
return;
}
IndexType seedIndex;
imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
//int seedValue = itkImage->GetPixel(seedIndex);
regionGrower->SetInput( itkImage );
regionGrower->AddSeed( seedIndex );
regionGrower->SetLower( m_LowerThreshold );
regionGrower->SetUpper( m_UpperThreshold );
regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
try
{
regionGrower->Update();
}
catch( ... )
{
MITK_ERROR << "Something went wrong!" << endl;
return;
}
m_SeedpointValue = regionGrower->GetSeedpointValue();
//initialize slider
if(m_CurrentRGDirectionIsUpwards)
{
UpperThresholdValueChanged.Send(m_UpperThreshold);
LowerThresholdValueChanged.Send(m_SeedpointValue);
}
else
{
UpperThresholdValueChanged.Send(m_SeedpointValue);
LowerThresholdValueChanged.Send(m_LowerThreshold);
}
m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
m_FeedbackNode->SetData( resultImage );
m_FeedbackNode->SetVisibility(true);
InitializeLevelWindow();
}
void mitk::PickingTool::StartRegionGrowing(itk::Image<TPixel, VImageDimension> *itkImage,
mitk::BaseGeometry *imageGeometry,
mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// convert world coordinates to image indices
IndexType seedIndex;
imageGeometry->WorldToIndex(seedPoint, seedIndex);
// perform region growing in desired segmented region
regionGrower->SetInput(itkImage);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(1);
regionGrower->SetUpper(255);
try
{
regionGrower->Update();
}
catch (const itk::ExceptionObject &)
{
return; // can't work
}
catch (...)
{
return;
}
// Store result and preview
mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput(), imageGeometry)->Clone();
mitk::LabelSetImage::Pointer resultLabelSetImage = mitk::LabelSetImage::New();
resultLabelSetImage->InitializeByLabeledImage(resultImage);
m_ResultNode->SetData(resultLabelSetImage);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkAdaptiveRegionGrowingToolGUI::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::BaseGeometry* imageGeometry, mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
typedef itk::MinimumMaximumImageCalculator<InputImageType> MinMaxValueFilterType;
if ( !imageGeometry->IsInside(seedPoint) )
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside of the image! Please choose a position inside the image!");
return;
}
IndexType seedIndex;
imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
if (m_SeedpointValue>m_UPPERTHRESHOLD || m_SeedpointValue<m_LOWERTHRESHOLD)
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
MITK_INFO << "Mean: " <<m_SeedPointValueMean;
return;
}
//Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
//is performed starting at the upper value going to the lower one
regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
regionGrower->SetInput( itkImage );
regionGrower->AddSeed( seedIndex );
//In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
//Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
regionGrower->SetLower( m_LOWERTHRESHOLD-1 );
regionGrower->SetUpper( m_UPPERTHRESHOLD+1);
try
{
regionGrower->Update();
}
catch(itk::ExceptionObject &exc)
{
QMessageBox errorInfo;
errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during region growing!");
errorInfo.setDetailedText(exc.what());
errorInfo.exec();
return; // can't work
}
catch( ... )
{
QMessageBox::critical( NULL, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
return;
}
mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
//initialize slider
m_Controls.m_PreviewSlider->setMinimum(m_LOWERTHRESHOLD);
mitk::ScalarType max = m_LOWERTHRESHOLD+resultImage->GetStatistics()->GetScalarValueMax();
if (max < m_UPPERTHRESHOLD)
m_Controls.m_PreviewSlider->setMaximum(max);
else
m_Controls.m_PreviewSlider->setMaximum(m_UPPERTHRESHOLD);
this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
if(m_CurrentRGDirectionIsUpwards)
{
m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean-1);
}
else
{
m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean+1);
}
this->m_SliderInitialized = true;
//create new node and then delete the old one if there is one
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData( resultImage );
// set some properties
newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
newNode->SetProperty("color", mitk::ColorProperty::New(0.0,1.0,0.0));
newNode->SetProperty("layer", mitk::IntProperty::New(1));
newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
//delete the old image, if there was one:
mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
m_DataStorage->Remove(binaryNode);
// now add result to data tree
m_DataStorage->Add( newNode, m_InputImageNode );
this->InitializeLevelWindow();
if(m_UseVolumeRendering)
this->EnableVolumeRendering(true);
m_UpdateSuggestedThreshold = true;// reset first stored threshold value
//Setting progress to finished
mitk::ProgressBar::GetInstance()->Progress(357);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer &result)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// convert world coordinates to image indices
IndexType startIndex;
IndexType seedIndex;
IndexType bestSeedIndex;
startIndex[0] = itkImage->GetLargestPossibleRegion().GetSize()[0]/2;
startIndex[1] = itkImage->GetLargestPossibleRegion().GetSize()[1]/2;
startIndex[2] = itkImage->GetLargestPossibleRegion().GetSize()[2]/2;
auto region = itkImage->GetLargestPossibleRegion();
auto spacing = itkImage->GetSpacing();
spacing[0] = itkImage->GetSpacing()[0];
spacing[1] = itkImage->GetSpacing()[1];
spacing[2] = itkImage->GetSpacing()[2];
int minimumDistance = 50 * 50 * (spacing[0] + spacing[1] + spacing[2]);
for (int x = -50; x < 50; ++x)
{
for (int y = -50; y < 50; ++y)
{
for (int z = -20; z < 20; ++z)
{
seedIndex[0] = startIndex[0] + x;
seedIndex[1] = startIndex[1] + y;
seedIndex[2] = startIndex[2] + z;
if (region.IsInside(seedIndex))
{
if (itkImage->GetPixel(seedIndex) > 0)
{
int newDistance = x*x*spacing[0] + y*y*spacing[1] + z*z*spacing[2];
if (newDistance < minimumDistance)
{
bestSeedIndex = seedIndex;
minimumDistance = newDistance;
}
}
}
}
}
}
seedIndex = bestSeedIndex;
MITK_INFO << "Seedpoint: " << seedIndex;
//perform region growing in desired segmented region
regionGrower->SetInput(itkImage);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(1);
regionGrower->SetUpper(255);
try
{
regionGrower->Update();
}
catch (const itk::ExceptionObject&)
{
return; // can't work
}
catch (...)
{
return;
}
//Store result and preview
mitk::CastToMitkImage(regionGrower->GetOutput(), result);
}
void mitk::RegionGrowingTool::StartRegionGrowing(itk::Image<TPixel, imageDimension>* inputImage, itk::Index<imageDimension> seedIndex, std::array<ScalarType, 2> thresholds, mitk::Image::Pointer& outputImage)
{
MITK_DEBUG << "Starting region growing at index " << seedIndex << " with lower threshold " << thresholds[0] << " and upper threshold " << thresholds[1];
typedef itk::Image<TPixel, imageDimension> InputImageType;
typedef itk::Image<DefaultSegmentationDataType, imageDimension> OutputImageType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// perform region growing in desired segmented region
regionGrower->SetInput(inputImage);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(thresholds[0]);
regionGrower->SetUpper(thresholds[1]);
try
{
regionGrower->Update();
}
catch(...)
{
return; // Should we do something?
}
typename OutputImageType::Pointer resultImage = regionGrower->GetOutput();
// Smooth result: Every pixel is replaced by the majority of the neighborhood
typedef itk::NeighborhoodIterator<OutputImageType> NeighborhoodIteratorType;
typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
typename NeighborhoodIteratorType::RadiusType radius;
radius.Fill(2); // for now, maybe make this something the user can adjust in the preferences?
NeighborhoodIteratorType neighborhoodIterator(radius, resultImage, resultImage->GetRequestedRegion());
ImageIteratorType imageIterator(resultImage, resultImage->GetRequestedRegion());
for (neighborhoodIterator.GoToBegin(), imageIterator.GoToBegin(); !neighborhoodIterator.IsAtEnd(); ++neighborhoodIterator, ++imageIterator)
{
DefaultSegmentationDataType voteYes(0);
DefaultSegmentationDataType voteNo(0);
for (unsigned int i = 0; i < neighborhoodIterator.Size(); ++i)
{
if (neighborhoodIterator.GetPixel(i) > 0)
{
voteYes += 1;
}
else
{
voteNo += 1;
}
}
if (voteYes > voteNo)
{
imageIterator.Set(1);
}
else
{
imageIterator.Set(0);
}
}
if (resultImage.IsNull())
{
MITK_DEBUG << "Region growing result is empty.";
}
// Can potentially have multiple regions, use connected component image filter to label disjunct regions
typedef itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType> ConnectedComponentImageFilterType;
typename ConnectedComponentImageFilterType::Pointer connectedComponentFilter = ConnectedComponentImageFilterType::New();
connectedComponentFilter->SetInput(resultImage);
connectedComponentFilter->Update();
typename OutputImageType::Pointer resultImageCC = connectedComponentFilter->GetOutput();
m_ConnectedComponentValue = resultImageCC->GetPixel(seedIndex);
outputImage = mitk::GrabItkImageMemory(resultImageCC);
}
void QmitkVirtualSurgery::DoPortalVeinSegment(itk::Image<TPixel, VImageDimension> *itkImage, mitk::Geometry3D* imageGeometry)
{
typedef itk::Image< TPixel, VImageDimension > InputImageType;
typedef typename InputImageType::IndexType IndexType;
// instantiate an ITK region growing filter, set its parameters
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
regionGrower->SetInput( itkImage ); // don't forget this
// determine a thresholding interval
IndexType seedIndex;
TPixel min( std::numeric_limits<TPixel>::max() );
TPixel max( std::numeric_limits<TPixel>::min() );
for ( mitk::PointSet::PointsConstIterator pointsIterator = m_PointSet->GetPointSet()->GetPoints()->Begin(); // really nice syntax to get an interator for all points
pointsIterator != m_PointSet->GetPointSet()->GetPoints()->End();
++pointsIterator )
{
// first test if this point is inside the image at all
if ( !imageGeometry->IsInside( pointsIterator.Value()) )
continue;
// convert world coordinates to image indices
imageGeometry->WorldToIndex( pointsIterator.Value(), seedIndex);
// get the pixel value at this point
TPixel currentPixelValue = itkImage->GetPixel( seedIndex );
// adjust minimum and maximum values
if (currentPixelValue > max)
max = currentPixelValue;
if (currentPixelValue < min)
min = currentPixelValue;
regionGrower->AddSeed( seedIndex );
}
std::cout << "Values between " << min << " and " << max << std::endl;
//min -= 30;
//max += 30;
// set thresholds and execute filter
regionGrower->SetLower( min );
regionGrower->SetUpper( max );
regionGrower->Update();
mitk::Image::Pointer resultImage = mitk::ImportItkImage( regionGrower->GetOutput() );
mitk::DataTreeNode::Pointer newNode = mitk::DataTreeNode::New();
newNode->SetData( resultImage );
// set some properties
newNode->SetProperty("binary", mitk::BoolProperty::New(true));
newNode->SetProperty("name", mitk::StringProperty::New("Portal Vein Image"));
newNode->SetProperty("color", mitk::ColorProperty::New(1.0,0.0,0.0));
//newNode->SetProperty("volumerendering", mitk::BoolProperty::New(true));
newNode->SetProperty("layer", mitk::IntProperty::New(1));
newNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
// add result to data tree
mitk::DataStorage::GetInstance()->Add( newNode );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
