void GenerateData_3DImage_CompareToReference()
{
int upperThr = 255;
int lowerThr = 60;
int outsideVal = 0;
int insideVal = 100;
us::ServiceReference<OclResourceService> ref = GetModuleContext()->GetServiceReference<OclResourceService>();
OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
resources->GetContext(); //todo why do i need to call this before GetMaximumImageSize()?
if(resources->GetMaximumImageSize(2, CL_MEM_OBJECT_IMAGE3D) == 0)
{
//GPU device does not support 3D images. Skip this test.
MITK_INFO << "Skipping test.";
return;
}
try{
m_oclBinaryFilter->SetInput( m_Random3DImage );
m_oclBinaryFilter->SetUpperThreshold( upperThr );
m_oclBinaryFilter->SetLowerThreshold( lowerThr );
m_oclBinaryFilter->SetOutsideValue( outsideVal );
m_oclBinaryFilter->SetInsideValue( insideVal );
m_oclBinaryFilter->Update();
mitk::Image::Pointer outputImage = mitk::Image::New();
outputImage = m_oclBinaryFilter->GetOutput();
// reference computation
//This is not optimal here, but since we use a random image
//we cannot know the reference image at this point.
typedef itk::Image< unsigned char, 3> ImageType;
typedef itk::BinaryThresholdImageFilter< ImageType, ImageType > ThresholdFilterType;
ImageType::Pointer itkInputImage = ImageType::New();
CastToItkImage( m_Random3DImage, itkInputImage );
ThresholdFilterType::Pointer refThrFilter = ThresholdFilterType::New();
refThrFilter->SetInput( itkInputImage );
refThrFilter->SetLowerThreshold( lowerThr );
refThrFilter->SetUpperThreshold( upperThr );
refThrFilter->SetOutsideValue( outsideVal );
refThrFilter->SetInsideValue( insideVal );
refThrFilter->Update();
mitk::Image::Pointer referenceImage = mitk::Image::New();
mitk::CastToMitkImage(refThrFilter->GetOutput(), referenceImage);
MITK_ASSERT_EQUAL( referenceImage, outputImage,
"OclBinaryThresholdFilter should be equal to regular itkBinaryThresholdImageFilter.");
}
catch(mitk::Exception &e)
{
std::string errorMessage = "Caught unexpected exception ";
errorMessage.append(e.what());
CPPUNIT_FAIL(errorMessage.c_str());
}
}
void mitk::RegionGrow3DTool::ConfirmSegmentation( std::string name, mitk::Color color)
{
mitk::DataNode::Pointer new_node = mitk::DataNode::New();
new_node->SetColor(color);
new_node->SetName(name);
new_node->SetProperty("binary", mitk::BoolProperty::New("true"));
mitk::Image* image = dynamic_cast<mitk::Image*> (m_FeedbackNode->GetData());
mitk::LevelWindow tempLevelWindow;
m_FeedbackNode->GetLevelWindow( tempLevelWindow, NULL, "levelWindow");
int upperThresholdLabeledImage = (short int) tempLevelWindow.GetRangeMax();
int lowerThresholdLabeledImage = (short int) tempLevelWindow.GetLowerWindowBound() + 1;
typedef itk::Image<int, 3> InputImageType;
typedef itk::Image<unsigned char, 3> SegmentationType;
typedef itk::BinaryThresholdImageFilter<InputImageType, SegmentationType> ThresholdFilterType;
ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
InputImageType::Pointer itkImage;
mitk::CastToItkImage(image, itkImage);
filter->SetInput(itkImage);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->SetUpperThreshold(upperThresholdLabeledImage);
filter->SetLowerThreshold(lowerThresholdLabeledImage);
filter->Update();
mitk::Image::Pointer new_image = mitk::Image::New();
mitk::CastToMitkImage(filter->GetOutput(), new_image);
//pad to original size
if (m_OriginalImageNode.GetPointer() != m_NodeToProceed.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, new_image);
padFilter->SetInput(1, dynamic_cast<mitk::Image*> (m_OriginalImageNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
new_image = padFilter->GetOutput();
}
new_node->SetData(new_image);
m_ToolManager->GetDataStorage()->Add(new_node);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_ToolManager->ActivateTool(-1);
}
BinaryImageType::Pointer readBinaryImage(const std::string& filename) {
ImageReaderType::Pointer reader = ImageReaderType::New();
reader->SetFileName(filename.c_str());
reader->Update();
// we make sure that the image really has value 0 and 1
typedef itk::BinaryThresholdImageFilter<BinaryImageType, BinaryImageType> ThresholdFilterType;
ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
thresholdFilter->SetInsideValue(1);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->SetLowerThreshold(1);
thresholdFilter->SetUpperThreshold(255);
thresholdFilter->SetInput(reader->GetOutput());
thresholdFilter->Update();
BinaryImageType::Pointer img = thresholdFilter->GetOutput();
img->DisconnectPipeline();
return img;
}
void mitk::BinaryThresholdULTool::UpdatePreview()
{
typedef itk::Image<int, 3> ImageType;
typedef itk::Image<unsigned char, 3> SegmentationType;
typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
mitk::Image::Pointer thresholdimage = dynamic_cast<mitk::Image*> (m_NodeForThresholding->GetData());
if(thresholdimage)
{
ImageType::Pointer itkImage = ImageType::New();
CastToItkImage(thresholdimage, itkImage);
ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
filter->SetInput(itkImage);
filter->SetLowerThreshold(m_CurrentLowerThresholdValue);
filter->SetUpperThreshold(m_CurrentUpperThresholdValue);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->Update();
mitk::Image::Pointer new_image = mitk::Image::New();
CastToMitkImage(filter->GetOutput(), new_image);
m_ThresholdFeedbackNode->SetData(new_image);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkBasicImageProcessing::StartButtonClicked()
{
if(!m_SelectedImageNode->GetNode()) return;
this->BusyCursorOn();
mitk::Image::Pointer newImage;
try
{
newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
}
catch ( std::exception &e )
{
QString exceptionString = "An error occured during image loading:\n";
exceptionString.append( e.what() );
QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
this->BusyCursorOff();
return;
}
// check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
if ( (! newImage) || (newImage->IsInitialized() == false) )
{
this->BusyCursorOff();
QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton );
return;
}
// check if operation is done on 4D a image time step
if(newImage->GetDimension() > 3)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(newImage);
timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
timeSelector->Update();
newImage = timeSelector->GetOutput();
}
// check if image or vector image
ImageType::Pointer itkImage = ImageType::New();
VectorImageType::Pointer itkVecImage = VectorImageType::New();
int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
if(isVectorImage > 1)
{
CastToItkImage( newImage, itkVecImage );
}
else
{
CastToItkImage( newImage, itkImage );
}
std::stringstream nameAddition("");
int param1 = m_Controls->sbParam1->value();
int param2 = m_Controls->sbParam2->value();
double dparam1 = m_Controls->dsbParam1->value();
double dparam2 = m_Controls->dsbParam2->value();
double dparam3 = m_Controls->dsbParam3->value();
try{
switch (m_SelectedAction)
{
case GAUSSIAN:
{
GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput( itkImage );
gaussianFilter->SetVariance( param1 );
gaussianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
nameAddition << "_Gaussian_var_" << param1;
std::cout << "Gaussian filtering successful." << std::endl;
break;
}
case MEDIAN:
{
MedianFilterType::Pointer medianFilter = MedianFilterType::New();
MedianFilterType::InputSizeType size;
size.Fill(param1);
medianFilter->SetRadius( size );
medianFilter->SetInput(itkImage);
medianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
nameAddition << "_Median_radius_" << param1;
std::cout << "Median Filtering successful." << std::endl;
break;
}
case TOTALVARIATION:
{
if(isVectorImage > 1)
{
VectorTotalVariationFilterType::Pointer TVFilter
= VectorTotalVariationFilterType::New();
TVFilter->SetInput( itkVecImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
else
{
ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New();
floatCaster->SetInput( itkImage );
floatCaster->Update();
FloatImageType::Pointer fImage = floatCaster->GetOutput();
TotalVariationFilterType::Pointer TVFilter
= TotalVariationFilterType::New();
TVFilter->SetInput( fImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
std::cout << "Total Variation Filtering successful." << std::endl;
break;
}
case DILATION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
dilationFilter->SetInput( itkImage );
dilationFilter->SetKernel( binaryBall );
dilationFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
nameAddition << "_Dilated_by_" << param1;
std::cout << "Dilation successful." << std::endl;
break;
}
case EROSION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
erosionFilter->SetInput( itkImage );
erosionFilter->SetKernel( binaryBall );
erosionFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
nameAddition << "_Eroded_by_" << param1;
std::cout << "Erosion successful." << std::endl;
break;
}
case OPENING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
openFilter->SetInput( itkImage );
openFilter->SetKernel( binaryBall );
openFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
nameAddition << "_Opened_by_" << param1;
std::cout << "Opening successful." << std::endl;
break;
}
case CLOSING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
closeFilter->SetInput( itkImage );
closeFilter->SetKernel( binaryBall );
closeFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
nameAddition << "_Closed_by_" << param1;
std::cout << "Closing successful." << std::endl;
break;
}
case GRADIENT:
{
GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
gradientFilter->SetInput( itkImage );
gradientFilter->SetSigma( param1 );
gradientFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
nameAddition << "_Gradient_sigma_" << param1;
std::cout << "Gradient calculation successful." << std::endl;
break;
}
case LAPLACIAN:
{
// the laplace filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
laplacianFilter->SetInput( fImage );
laplacianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
nameAddition << "_Second_Derivative";
std::cout << "Laplacian filtering successful." << std::endl;
break;
}
case SOBEL:
{
// the sobel filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
sobelFilter->SetInput( fImage );
sobelFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
nameAddition << "_Sobel";
std::cout << "Edge Detection successful." << std::endl;
break;
}
case THRESHOLD:
{
ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
thFilter->SetInsideValue(1);
thFilter->SetOutsideValue(0);
thFilter->SetInput(itkImage);
thFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
nameAddition << "_Threshold";
std::cout << "Thresholding successful." << std::endl;
break;
}
case INVERSION:
{
InversionFilterType::Pointer invFilter = InversionFilterType::New();
mitk::ScalarType min = newImage->GetScalarValueMin();
mitk::ScalarType max = newImage->GetScalarValueMax();
invFilter->SetMaximum( max + min );
invFilter->SetInput(itkImage);
invFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
nameAddition << "_Inverted";
std::cout << "Image inversion successful." << std::endl;
break;
}
case DOWNSAMPLING:
{
ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
downsampler->SetInput( itkImage );
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
downsampler->SetInterpolator( interpolator );
downsampler->SetDefaultPixelValue( 0 );
ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
spacing *= (double) param1;
downsampler->SetOutputSpacing( spacing );
downsampler->SetOutputOrigin( itkImage->GetOrigin() );
downsampler->SetOutputDirection( itkImage->GetDirection() );
ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
for ( int i = 0; i < 3; ++i )
{
size[i] /= param1;
}
downsampler->SetSize( size );
downsampler->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
nameAddition << "_Downsampled_by_" << param1;
std::cout << "Downsampling successful." << std::endl;
break;
}
case FLIPPING:
{
FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
flipper->SetInput( itkImage );
itk::FixedArray<bool, 3> flipAxes;
for(int i=0; i<3; ++i)
{
if(i == param1)
{
flipAxes[i] = true;
}
else
{
flipAxes[i] = false;
}
}
flipper->SetFlipAxes(flipAxes);
flipper->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
std::cout << "Image flipping successful." << std::endl;
break;
}
case RESAMPLING:
{
std::string selectedInterpolator;
ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
switch (m_SelectedInterpolation)
{
case LINEAR:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
case NEAREST:
{
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Nearest";
break;
}
default:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
}
resampler->SetInput( itkImage );
resampler->SetOutputOrigin( itkImage->GetOrigin() );
ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
ImageType::SpacingType input_spacing = itkImage->GetSpacing();
ImageType::SizeType output_size;
ImageType::SpacingType output_spacing;
output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
output_spacing [0] = dparam1;
output_spacing [1] = dparam2;
output_spacing [2] = dparam3;
resampler->SetSize( output_size );
resampler->SetOutputSpacing( output_spacing );
resampler->SetOutputDirection( itkImage->GetDirection() );
resampler->UpdateLargestPossibleRegion();
ImageType::Pointer resampledImage = resampler->GetOutput();
newImage = mitk::ImportItkImage( resampledImage );
nameAddition << "_Resampled_" << selectedInterpolator;
std::cout << "Resampling successful." << std::endl;
break;
}
case RESCALE:
{
FloatImageType::Pointer floatImage = FloatImageType::New();
CastToItkImage( newImage, floatImage );
itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::Pointer filter = itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::New();
filter->SetInput(0, floatImage);
filter->SetOutputMinimum(dparam1);
filter->SetOutputMaximum(dparam2);
filter->Update();
floatImage = filter->GetOutput();
newImage = mitk::Image::New();
newImage->InitializeByItk(floatImage.GetPointer());
newImage->SetVolume(floatImage->GetBufferPointer());
nameAddition << "_Rescaled";
std::cout << "Rescaling successful." << std::endl;
break;
}
default:
this->BusyCursorOff();
return;
}
}
catch (...)
{
this->BusyCursorOff();
QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
return;
}
newImage->DisconnectPipeline();
// adjust level/window to new image
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( newImage );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
// compose new image name
std::string name = m_SelectedImageNode->GetNode()->GetName();
if (name.find(".pic.gz") == name.size() -7 )
{
name = name.substr(0,name.size() -7);
}
name.append( nameAddition.str() );
// create final result MITK data storage node
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "levelwindow", levWinProp );
result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
result->SetData( newImage );
// for vector images, a different mapper is needed
if(isVectorImage > 1)
{
mitk::VectorImageMapper2D::Pointer mapper =
mitk::VectorImageMapper2D::New();
result->SetMapper(1,mapper);
}
// reset GUI to ease further processing
// this->ResetOneImageOpPanel();
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
if ( m_Controls->cbHideOrig->isChecked() == true )
m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
// TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result);
// show the results
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->BusyCursorOff();
}
int mitkToFCompositeFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFCompositeFilter");
//initialize composite filter
mitk::ToFCompositeFilter::Pointer compositeFilter = mitk::ToFCompositeFilter::New();
//Initialize threshold filter
ThresholdFilterType::Pointer thresholdFilter = ThresholdFilterType::New();
int threshold_min = 5;
int threshold_max = 100;
thresholdFilter->SetOutsideValue(0.0);
thresholdFilter->SetLower(threshold_min);
thresholdFilter->SetUpper(threshold_max);
compositeFilter->SetThresholdFilterParameter(threshold_min, threshold_max);
//Initialize spatial median filter
MedianFilterType::Pointer medianFilter = MedianFilterType::New();
//Initialize bilateral filter
BilateralImageFilterType::Pointer bilateralFilter = BilateralImageFilterType::New();
float domainSigma = 4;
float rangeSigma = 50;
float kernelRadius = 3;
bilateralFilter->SetDomainSigma(domainSigma);
bilateralFilter->SetRangeSigma(rangeSigma);
bilateralFilter->SetRadius(kernelRadius);
compositeFilter->SetBilateralFilterParameter(domainSigma,rangeSigma,kernelRadius);
//Initialize pipeline
ItkImageType_2D::Pointer itkInputImage = ItkImageType_2D::New();
mitk::Image::Pointer mitkInputImage = mitk::Image::New();
CreateRandomDistanceImage(100,100,itkInputImage,mitkInputImage);
ItkImageType_2D::Pointer itkOutputImage;
compositeFilter->SetInput(mitkInputImage);
mitk::Image::Pointer mitkOutputImage = compositeFilter->GetOutput();
//-------------------------------------------------------------------------------------------------------
//Apply first filter only (threshold)
//standard variant
thresholdFilter->SetInput(itkInputImage);
itkOutputImage = thresholdFilter->GetOutput();
itkOutputImage->Update();
//variant with composite filter
compositeFilter->SetApplyThresholdFilter(true);
compositeFilter->SetApplyMedianFilter(false);
compositeFilter->SetApplyTemporalMedianFilter(false);
compositeFilter->SetApplyBilateralFilter(false);
mitkOutputImage->Update();
//compare output
mitk::Image::Pointer itkOutputImageConverted;
mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(*itkOutputImageConverted, *mitkOutputImage, mitk::eps, true),
"Test threshold filter in pipeline");
//-------------------------------------------------------------------------------------------------------
//Apply first and second filter
//standard variant
medianFilter->SetInput(thresholdFilter->GetOutput());
itkOutputImage = medianFilter->GetOutput();
itkOutputImage->Update();
//variant with composite filter
compositeFilter->SetApplyMedianFilter(true);
mitkOutputImage->Update();
//compare output
mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(*itkOutputImageConverted, *mitkOutputImage, mitk::eps, true),
"Test threshold and median filter in pipeline");
//-------------------------------------------------------------------------------------------------------
//Apply first three filters
//standard variant
bilateralFilter->SetInput(medianFilter->GetOutput());
itkOutputImage = bilateralFilter->GetOutput();
itkOutputImage->Update();
//variant with composite filter
compositeFilter->SetApplyBilateralFilter(true);
mitkOutputImage->Update();
//compare output
mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
MITK_TEST_CONDITION_REQUIRED( mitk::Equal(*itkOutputImageConverted, *mitkOutputImage, mitk::eps, true),
"Test threshold filter, bilateral filter and temporal median filter in pipeline");
//-------------------------------------------------------------------------------------------------------
// TODO: Rewrite this. This don't make sense. the itk reference applies a median filter
// and threshold filter afterwards. The composite filter does it in the other directtion.
// also the input of random image stacks is never set into the composite filter
//Apply all filters
//generate image stack
// ItkImageType_3D::Pointer itkInputImage3D = ItkImageType_3D::New();
// mitk::Image::Pointer mitkImage3D = mitk::Image::New();
// CreateRandomDistanceImageStack(100,100,12,itkInputImage3D,mitkImage3D);
//
// //standard variant
// ItkImageType_2D::Pointer medianFilteredImage = ItkImageType_2D::New();
// ApplyTemporalMedianFilter(mitkImage3D,medianFilteredImage);
// thresholdFilter->SetInput(medianFilteredImage);
// itkOutputImage->Update();
//
// //variant with composite filter
// compositeFilter->SetApplyTemporalMedianFilter(true);
// mitkOutputImage->Update();
//
// //compare output
// mitk::CastToMitkImage(itkOutputImage,itkOutputImageConverted);
// pipelineSuccess = CompareImages(itkOutputImageConverted,mitkOutputImage);
// MITK_TEST_CONDITION_REQUIRED(pipelineSuccess,"Test all filters in pipeline");
//-------------------------------------------------------------------------------------------------------
//Check set/get functions
mitk::Image::Pointer newImage = mitk::Image::New();
mitk::Image::Pointer returnedImage;
compositeFilter->SetInput(newImage);
returnedImage = compositeFilter->GetInput();
MITK_TEST_CONDITION_REQUIRED(newImage == returnedImage,"Get/Set empty image");
compositeFilter->SetApplyTemporalMedianFilter(false);
MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyTemporalMedianFilter()==false,"Get/Set ApplyTemporalMedianFilter");
compositeFilter->SetApplyMedianFilter(false);
MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyMedianFilter()==false,"Get/Set ApplyMedianFilter");
compositeFilter->SetApplyThresholdFilter(false);
MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyThresholdFilter()==false,"Get/Set ApplyThresholdFilter");
compositeFilter->SetApplyBilateralFilter(false);
MITK_TEST_CONDITION_REQUIRED(compositeFilter->GetApplyBilateralFilter()==false,"Get/Set ApplyBilateralFilter");
//-------------------------------------------------------------------------------------------------------
MITK_TEST_END();
}
/**
This function is testing the class mitk::OclContextManager.
*/
int mitkOclBinaryThresholdImageFilterTest( int /*argc*/, char**/* argv[]*/ )
{
MITK_TEST_BEGIN("mitkOclBinaryThresholdImageFilterTest");
ServiceReference ref = GetModuleContext()->GetServiceReference<OclResourceService>();
MITK_TEST_CONDITION_REQUIRED( ref != 0, "Got valid ServiceReference" );
OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
MITK_TEST_CONDITION_REQUIRED( resources != NULL, "OpenCL Resource service available." );
cl_context gpuContext = resources->GetContext();
MITK_TEST_CONDITION_REQUIRED( gpuContext != NULL, "Got not-null OpenCL context.");
cl_device_id gpuDevice = resources->GetCurrentDevice();
MITK_TEST_CONDITION_REQUIRED( gpuDevice != NULL, "Got not-null OpenCL device.");
//Create a random reference image
mitk::Image::Pointer inputImage = mitk::ImageGenerator::GenerateRandomImage<unsigned char>(119, 204, 52, 1, // dimension
1.0f, 1.0f, 1.0f, // spacing
255, 0); // max, min
MITK_TEST_CONDITION_REQUIRED( inputImage.IsNotNull(), "Input (random) mitk::Image object instantiated.");
// FIXME: could also be random values
int upperThr = 255;
int lowerThr = 60;
int outsideVal = 0;
int insideVal = 100;
mitk::OclBinaryThresholdImageFilter* oclFilter = new mitk::OclBinaryThresholdImageFilter;
MITK_TEST_CONDITION_REQUIRED( oclFilter != NULL, "Filter was created. ");
oclFilter->SetInput( inputImage );
oclFilter->SetUpperThreshold( upperThr );
oclFilter->SetLowerThreshold( lowerThr );
oclFilter->SetOutsideValue( outsideVal );
oclFilter->SetInsideValue( insideVal );
oclFilter->Update();
mitk::Image::Pointer outputImage = mitk::Image::New();
outputImage = oclFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED( outputImage.IsNotNull(), "Filter returned an not-NULL image. ");
// reference computation
typedef itk::Image< unsigned char, 3> ImageType;
typedef itk::BinaryThresholdImageFilter< ImageType, ImageType > ThresholdFilterType;
ImageType::Pointer itkInputImage = ImageType::New();
CastToItkImage( inputImage, itkInputImage );
ThresholdFilterType::Pointer refThrFilter = ThresholdFilterType::New();
refThrFilter->SetInput( itkInputImage );
refThrFilter->SetLowerThreshold( lowerThr );
refThrFilter->SetUpperThreshold( upperThr );
refThrFilter->SetOutsideValue( outsideVal );
refThrFilter->SetInsideValue( insideVal );
typedef itk::SubtractImageFilter< ImageType, ImageType > SubtractFilterType;
SubtractFilterType::Pointer subFilt = SubtractFilterType::New();
ImageType::Pointer gpuReferenceImage = ImageType::New();
CastToItkImage( oclFilter->GetOutput() ,gpuReferenceImage );
subFilt->SetInput1( refThrFilter->GetOutput() );
subFilt->SetInput2( gpuReferenceImage );
typedef itk::StatisticsImageFilter< ImageType > StatFilterType;
StatFilterType::Pointer stats = StatFilterType::New();
stats->SetInput( subFilt->GetOutput() );
stats->Update();
MITK_TEST_CONDITION( stats->GetMaximum() == 0, "Maximal value in the difference image is 0.");
MITK_TEST_CONDITION( stats->GetMinimum() == 0, "Minimal value in the difference image is 0.")
MITK_TEST_END();
}
void QmitkTbssSkeletonizationView::Project()
{
typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
typedef itk::ProjectionFilter ProjectionFilterType;
typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
mitk::Image::Pointer meanImage = mitk::Image::New();
mitk::Image::Pointer subjects = mitk::Image::New();
mitk::Image::Pointer tubular = mitk::Image::New();
for ( int i=0; i<nodes.size(); i++ )
{
// process only on valid nodes
mitk::BaseData* nodeData = nodes[i]->GetData();
if(nodeData)
{
if(QString("Image").compare(nodeData->GetNameOfClass())==0)
{
mitk::Image* img = static_cast<mitk::Image*>(nodeData);
if(img->GetDimension() == 3)
{
bool isBinary(false);
nodes[i]->GetBoolProperty("binary", isBinary);
if(isBinary)
{
tubular = img;
}
else
{
meanImage = img;
}
}
else if(img->GetDimension() == 4)
{
subjects = img;
}
}
}
}
Float4DImageType::Pointer allFA = ConvertToItk(subjects);
// Calculate skeleton
FloatImageType::Pointer itkImg = FloatImageType::New();
mitk::CastToItkImage(meanImage, itkImg);
skeletonizer->SetInput(itkImg);
skeletonizer->Update();
FloatImageType::Pointer output = skeletonizer->GetOutput();
mitk::Image::Pointer mitkOutput = mitk::Image::New();
mitk::CastToMitkImage(output, mitkOutput);
AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
// Retrieve direction image needed later by the projection filter
DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
// Calculate distance image
DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
distanceMapFilter->SetInput(output);
distanceMapFilter->Update();
FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
if(m_Controls->m_OutputDistanceMap->isChecked())
{
mitk::Image::Pointer mitkDistance = mitk::Image::New();
mitk::CastToMitkImage(distanceMap, mitkDistance);
AddToDataStorage(mitkDistance, "distance map");
}
// Do projection
// Ask a threshold to create a skeleton mask
double threshold = -1.0;
while(threshold == -1.0)
{
threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
tr("Threshold:"), QLineEdit::Normal,
0.2);
if(threshold < 0.0 || threshold > 1.0)
{
QMessageBox msgBox;
msgBox.setText("Please choose a value between 0 and 1");
msgBox.exec();
threshold = -1.0;
}
}
typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
thresholder->SetInput(output);
thresholder->SetLowerThreshold(threshold);
thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
thresholder->SetOutsideValue(0);
thresholder->SetInsideValue(1);
thresholder->Update();
CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
if(m_Controls->m_OutputMask->isChecked())
{
mitk::Image::Pointer mitkThresholded = mitk::Image::New();
mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
AddToDataStorage(mitkThresholded, maskName);
}
CharImageType::Pointer itkTubular = CharImageType::New();
mitk::CastToItkImage(tubular, itkTubular);
ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
projectionFilter->SetDistanceMap(distanceMap);
projectionFilter->SetDirections(directionImg);
projectionFilter->SetAllFA(allFA);
projectionFilter->SetTube(itkTubular);
projectionFilter->SetSkeleton(thresholdedImg);
projectionFilter->Project();
Float4DImageType::Pointer projected = projectionFilter->GetProjections();
mitk::Image::Pointer mitkProjections = mitk::Image::New();
mitk::CastToMitkImage(projected, mitkProjections);
AddToDataStorage(mitkProjections, "all_FA_projected");
}
void WholeCellSeg::BinarizationForRealBounds(){
if( !nuc_im_set || !cyt_im_set ){
std::cerr<<"Complete segmenting nuclei and set input imge before starting segmentation\n";
return;
}
itk::SizeValueType size1=cyt_im_inp->GetLargestPossibleRegion().GetSize()[0];
itk::SizeValueType size2=cyt_im_inp->GetLargestPossibleRegion().GetSize()[1];
if( ( size1 != nuclab_inp->GetLargestPossibleRegion().GetSize()[0] ) ||
( size2 != nuclab_inp->GetLargestPossibleRegion().GetSize()[1] ) )
{
std::cerr<<"The input images must be of the same size\n";
return;
}
typedef unsigned short int UShortPixelType;
typedef itk::ImageRegionIteratorWithIndex< UShortImageType > IteratorType;
typedef itk::ImageRegionConstIterator< UShortImageType > ConstIteratorType;
typedef itk::Statistics::ScalarImageToHistogramGenerator< IntImageType > ScalarImageToHistogramGeneratorType;
typedef ScalarImageToHistogramGeneratorType::HistogramType HistogramType;
typedef itk::OtsuMultipleThresholdsCalculator< HistogramType > CalculatorType;
typedef itk::RescaleIntensityImageFilter< UShortImageType, IntImageType > RescaleUsIntType;
typedef itk::RescaleIntensityImageFilter< UShortImageType, UShortImageType > RescaleUsUsType;
typedef itk::BinaryThresholdImageFilter< IntImageType, UShortImageType > ThreshFilterType;
typedef itk::BinaryThresholdImageFilter< UShortImageType, UShortImageType > ThresholdFilterType;
typedef itk::OrImageFilter< UShortImageType, UShortImageType, UShortImageType > OrFilterType;
typedef itk::BinaryBallStructuringElement< UShortPixelType, 2 > StructuringElementType;
typedef itk::BinaryErodeImageFilter< UShortImageType, UShortImageType, StructuringElementType > ErodeFilterType;
typedef itk::BinaryDilateImageFilter< UShortImageType, UShortImageType, StructuringElementType > DilateFilterType;
unsigned char *in_Image;
itk::SizeValueType ind=0;
//Call Yousef's binarization method if the number of bin levels is < 2
if( num_levels < 2 ){
bin_Image = (unsigned short *) malloc (size1*size2*sizeof(unsigned short));
for(itk::SizeValueType j=0; j<size2; ++j)
for(itk::SizeValueType i=0; i<size1; ++i)
BIN_Image(i,j)=255;
in_Image = (unsigned char *) malloc (size1*size2);
if( ( in_Image == NULL ) || ( bin_Image == NULL ) ){
std::cerr << "Memory allocation for binarization of image failed\n";
return;
}
RescaleUsUsType::Pointer rescaleususfilter = RescaleUsUsType::New();
rescaleususfilter->SetInput( cyt_im_inp );
rescaleususfilter->SetOutputMaximum( itk::NumericTraits<unsigned char>::max() );
rescaleususfilter->SetOutputMinimum( 0 );
rescaleususfilter->Update();
UShortImageType::Pointer resc_cyt_im = UShortImageType::New();
resc_cyt_im = rescaleususfilter->GetOutput();
ConstIteratorType pix_buf1( resc_cyt_im, resc_cyt_im->GetRequestedRegion() );
for ( pix_buf1.GoToBegin(); !pix_buf1.IsAtEnd(); ++pix_buf1, ++ind )
in_Image[ind]=(unsigned char)(pix_buf1.Get());
int ok = 0;
ok = Cell_Binarization_2D(in_Image,bin_Image, size1, size2, shift_bin);
free( in_Image );
if( !ok ){
std::cerr<<"Binarization Failed\n";
return;
}
//copy the output binary image into the ITK image
intermediate_bin_im_out = UShortImageType::New();
UShortImageType::PointType origin;
origin[0] = 0;
origin[1] = 0;
intermediate_bin_im_out->SetOrigin( origin );
UShortImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
UShortImageType::SizeType size;
size[0] = size1; // size along X
size[1] = size2; // size along Y
UShortImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
intermediate_bin_im_out->SetRegions( region );
intermediate_bin_im_out->Allocate();
intermediate_bin_im_out->FillBuffer(0);
intermediate_bin_im_out->Update();
itk::SizeValueType dum,dum1;
dum = 0;
dum1 = USHRT_MAX;
//unsigned int asd,asd1; asd=0; asd1=0;
IteratorType iterator ( intermediate_bin_im_out, intermediate_bin_im_out->GetRequestedRegion() );
for(itk::SizeValueType i=0; i < (size1*size2); ++i){
if( bin_Image[i] )
iterator.Set( dum1 );
else
iterator.Set( dum );
++iterator;
}
}
//Call multi level binarization method if the number of bin levels is >= 2
else{
RescaleUsIntType::Pointer rescaleusintfilter = RescaleUsIntType::New();
ScalarImageToHistogramGeneratorType::Pointer scalarImageToHistogramGenerator = ScalarImageToHistogramGeneratorType::New();
rescaleusintfilter->SetInput( cyt_im_inp );
rescaleusintfilter->SetOutputMaximum( itk::NumericTraits<unsigned short>::max() );
rescaleusintfilter->SetOutputMinimum( 0 );
rescaleusintfilter->Update();
ThreshFilterType::Pointer threshfilter = ThreshFilterType::New();
CalculatorType::Pointer calculator = CalculatorType::New();
scalarImageToHistogramGenerator->SetNumberOfBins( 255 );
calculator->SetNumberOfThresholds( num_levels );
threshfilter->SetOutsideValue( (int)0 );
threshfilter->SetInsideValue( (int)USHRT_MAX );
scalarImageToHistogramGenerator->SetInput( rescaleusintfilter->GetOutput() );
scalarImageToHistogramGenerator->Compute();
calculator->SetInputHistogram( scalarImageToHistogramGenerator->GetOutput() );
threshfilter->SetInput( rescaleusintfilter->GetOutput() );
calculator->Update();
const CalculatorType::OutputType &thresholdVector = calculator->GetOutput();
CalculatorType::OutputType::const_iterator itNum = thresholdVector.begin();
int lowerThreshold,upperThreshold;
for( int i=0; i<(num_levels-num_levels_incl); ++i ) ++itNum;
lowerThreshold = static_cast<unsigned short>(*itNum);
upperThreshold = itk::NumericTraits<unsigned short>::max();
threshfilter->SetLowerThreshold( lowerThreshold );
threshfilter->SetUpperThreshold( upperThreshold );
threshfilter->Update();
intermediate_bin_im_out = UShortImageType::New();
intermediate_bin_im_out = threshfilter->GetOutput();
}
//Fill holes left by the nuclei
ThresholdFilterType::Pointer binarythreshfilter = ThresholdFilterType::New();
binarythreshfilter->SetInsideValue( USHRT_MAX );
binarythreshfilter->SetOutsideValue( 0 );
binarythreshfilter->SetLowerThreshold( 1 );
binarythreshfilter->SetUpperThreshold( USHRT_MAX );
binarythreshfilter->SetInput( nuclab_inp );
OrFilterType::Pointer orfilter = OrFilterType::New();
orfilter->SetInput1( binarythreshfilter->GetOutput() );
orfilter->SetInput2( intermediate_bin_im_out );
//dialate and erode
ErodeFilterType::Pointer binaryErode = ErodeFilterType::New();
DilateFilterType::Pointer binaryDilate = DilateFilterType::New();
StructuringElementType structuringElement;
structuringElement.SetRadius( 3 ); // 3x3 structuring element
structuringElement.CreateStructuringElement();
binaryErode->SetKernel( structuringElement );
binaryErode->SetErodeValue( USHRT_MAX );
binaryDilate->SetDilateValue( USHRT_MAX );
binaryDilate->SetKernel( structuringElement );
binaryErode->SetInput( binaryDilate->GetOutput() );
binaryDilate->SetInput( orfilter->GetOutput() );
//erode and dialate
ErodeFilterType::Pointer binaryErode1 = ErodeFilterType::New();
DilateFilterType::Pointer binaryDilate1 = DilateFilterType::New();
binaryErode1->SetKernel( structuringElement );
binaryErode1->SetErodeValue( USHRT_MAX );
binaryDilate1->SetDilateValue( USHRT_MAX );
binaryDilate1->SetKernel( structuringElement );
binaryErode1->SetInput( binaryErode->GetOutput() );
binaryDilate1->SetInput( binaryErode1->GetOutput() );
binaryDilate1->Update();
//Get pointer to the final binary image and return it to calling function
UShortImageType::Pointer image_bin = UShortImageType::New();
image_bin = binaryDilate1->GetOutput();
bin_im_out = image_bin;
bin_done = 1;
//Update bin array
ind=0;
if( draw_real_bounds ){
ConstIteratorType pix_buf3( bin_im_out, bin_im_out->GetRequestedRegion() );
for ( pix_buf3.GoToBegin(); !pix_buf3.IsAtEnd(); ++pix_buf3, ++ind )
bin_Image[ind]=(pix_buf3.Get());
}else
free( bin_Image );
/*
typedef itk::ImageFileWriter< UShortImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName( "bin_info.tif" );
writer->SetInput( bin_im_out );//RescaleIntIO1--finalO/P
writer->Update();
*/
return;
}
//腐蚀操作
void segmentation::erosionOperation()//未用到
{
const unsigned int Dimension = 3;
typedef unsigned char InputPixelType;
typedef unsigned char OutputPixelType;
typedef itk::Image< InputPixelType, Dimension > InputImageType;
typedef itk::Image< OutputPixelType, Dimension > OutputImageType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
typedef itk::ImageFileWriter< OutputImageType > WriterType;
typedef itk::BinaryThresholdImageFilter< InputImageType, InputImageType > ThresholdFilterType;
typedef itk::BinaryBallStructuringElement<
InputPixelType,
Dimension > StructuringElementType;
typedef itk::BinaryErodeImageFilter<
InputImageType,
OutputImageType,
StructuringElementType > ErodeFilterType;
ReaderType::Pointer reader = ReaderType::New();
WriterType::Pointer writerErosion = WriterType::New();
ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
ErodeFilterType::Pointer binaryErode = ErodeFilterType::New();
StructuringElementType structuringElementErosion;
reader->SetFileName( initFileName );//读入二值图
reader->Update();
InputImageType::Pointer inputImage = InputImageType::New();
InputImageType::IndexType voxelIndex;
inputImage = reader->GetOutput();
InputImageType::SizeType imgSize = inputImage->GetLargestPossibleRegion().GetSize();
long vol = 0;
unsigned char temp;
float r;
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)// 255 for PED
vol += 1;
}
r = pow((3 * vol) / (4 * PI), (1.0 / 3)) ;
r = r / 20;//experiment data
structuringElementErosion.SetRadius( r ); // 3x3 structuring element
structuringElementErosion.CreateStructuringElement();
binaryErode->SetKernel( structuringElementErosion );
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
string erosionFileName;
erosionFileName = filePrefix + "_erosionResult.mhd";
strcpy(outputFileName, erosionFileName.c_str());//string to char*
writerErosion->SetFileName(outputFileName);
const InputPixelType lowerThreshold = 255;
const InputPixelType upperThreshold = 255;
thresholder->SetInput( reader->GetOutput() );
InputPixelType background = 0;
InputPixelType foreground = 255;
thresholder->SetOutsideValue( background );
thresholder->SetInsideValue( foreground );
thresholder->SetLowerThreshold( lowerThreshold );
thresholder->SetUpperThreshold( upperThreshold );
binaryErode->SetInput( thresholder->GetOutput() );
binaryErode->SetErodeValue( foreground );
writerErosion->SetInput( binaryErode->GetOutput() );
writerErosion->Update();
//binaryErode->GetOutput()->GetPixel(index);//获取像素值失败
//腐蚀结果叠加到原图
typedef itk::Image< unsigned short, Dimension > OriginalImageType;
typedef itk::ImageFileReader<OriginalImageType>OriginalReaderType;
OriginalReaderType::Pointer orignalImgreader = OriginalReaderType::New();
OriginalImageType::Pointer originalImage = OriginalImageType::New();
OriginalReaderType::IndexType originalImgVoxelIndex;
reader->SetFileName(outputFileName);//读入腐蚀结果图像
reader->Update();
inputImage = reader->GetOutput();
orignalImgreader->SetFileName(inputFileName);//读入原图像
orignalImgreader->Update();
originalImage = orignalImgreader->GetOutput();
for(int z = 0; z < imgSize[2]; z++)
for(int y = 0; y < imgSize[1]; y++)
for(int x = 0; x < imgSize[0]; x++)
{
voxelIndex[0] = x;
voxelIndex[1] = y;
voxelIndex[2] = z;
originalImgVoxelIndex[0] = x;
originalImgVoxelIndex[1] = y;
originalImgVoxelIndex[2] = z;
temp = inputImage->GetPixel(voxelIndex);
if(temp == 255)
originalImage->SetPixel(originalImgVoxelIndex, 65535);
}
//输出结果
typedef itk::ImageFileWriter<OriginalImageType>NewWriterType;
NewWriterType::Pointer writer = NewWriterType::New();
//文件前缀名
filePrefix = inputFileName;//char* to string
filePrefix = filePrefix.substr(0, filePrefix.length() - 4);
filePrefix = filePrefix + "_refinedResult.mhd";
strcpy(outputFileName, filePrefix.c_str());//string to char*
writer->SetFileName(outputFileName);
writer->SetInput(originalImage);
writer->Update();
emit returnInternalFileName(initResultFileName);//更新原视图
emit returnOutputFileName(outputFileName);//显示结果图
}
void unmix_threshold(InputImageType::Pointer im[],InputImageType::Pointer om[],int n,int GFP_channel,int AF_channel, int thresh)
{
printf("Unnmixing %d channels ...\n",n);
InputImageType::SizeType size = im[0]->GetLargestPossibleRegion().GetSize();
printf("I'm here\n");
MedianFilterType::Pointer filt[15];
IteratorType iterator[15];
//IteratorType assigniter[15];
InputImageType::SizeType radius;
radius[0]=1;
radius[1]=1;
radius[2]=1;
InputImageType::SizeType imagesize = im[0]->GetLargestPossibleRegion().GetSize();
InputImageType::IndexType imageindex;
imageindex.Fill(0);
InputImageType::RegionType region;
region.SetSize(imagesize);
region.SetIndex(imageindex);
double max_values[15];
for(int counter=0; counter<n; counter++)
{
printf("\tPerforming median filtering on channel %d ...",counter+1);
filt[counter]=MedianFilterType::New();
filt[counter]->SetRadius(radius);
filt[counter]->SetInput(im[counter]);
filt[counter]->Update();
om[counter]=filt[counter]->GetOutput();
iterator[counter]=IteratorType(om[counter],om[counter]->GetLargestPossibleRegion());
iterator[counter].GoToBegin();
max_values[counter]=-1;
printf(" Done %d.\n",counter+1);
for(;!iterator[counter].IsAtEnd();++iterator[counter])
{
if(max_values[counter]<iterator[counter].Value())
max_values[counter] = iterator[counter].Value();
}
// printf("Max%d = %lf\n",counter,max_values[counter]);
iterator[counter].GoToBegin();
}
printf("Binarizing the Autofluoroscence Channel\n");
ThresholdFilterType::Pointer tfilter = ThresholdFilterType::New();
tfilter->SetInput(om[AF_channel]);
tfilter->SetLowerThreshold(thresh);
tfilter->SetUpperThreshold(255);
tfilter->SetInsideValue(255);
tfilter->SetOutsideValue(0);
om[AF_channel] = tfilter->GetOutput();
tfilter->Update();
//int total_voxels = size[0]*size[1]*size[2];
int num_processed = 0;
//Removing Small components
om[AF_channel] = getLargeComponents(om[AF_channel],thresh);
printf("\tComputing foreground in AF channel ... ");
for(;!iterator[0].IsAtEnd();)
{
num_processed++;
unsigned char temp = iterator[2].Value();///max_values[co];
if(temp > 0)
{
iterator[GFP_channel].Set(0);
//iterator[0].Set(0);
}
for(int co = 0; co<n; co++)
{
++iterator[co];
}
}
printf(" Done.\n");
}
