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(); }
void segment::Execute(int first,int last,double sig_min, double sig_max, double propagation, double curvature, double advection, double rms, int iterations, double alpha, double beta, double distance){ ifstream myfile ("/home/gustavo/temp/endocardium.txt"); for(int i =first; i<last;i++){ typedef float InternalPixelType; const unsigned int Dimension = 2; typedef itk::Image< InternalPixelType, Dimension > InternalImageType; typedef unsigned char OutputPixelType; typedef itk::Image< OutputPixelType, Dimension > OutputImageType; typedef itk::BinaryThresholdImageFilter< InternalImageType, OutputImageType > ThresholdingFilterType; ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New(); thresholder->SetLowerThreshold( -1000.0 ); thresholder->SetUpperThreshold( 0.0 ); thresholder->SetOutsideValue( 0 ); thresholder->SetInsideValue( 255 ); typedef itk::ImageFileReader< InternalImageType > ReaderType; typedef itk::ImageFileWriter< OutputImageType > WriterType; ReaderType::Pointer reader = ReaderType::New(); WriterType::Pointer writer = WriterType::New(); //WriterType::Pointer writer_out = WriterType::New(); stringstream ss; string name = "/home/gustavo/temp/cine_"; string type = ".tif"; ss<<name<<(i+1)<<type; string filename = ss.str(); ss.str(""); reader->SetFileName(filename); reader->Update(); InternalImageType::Pointer val = reader->GetOutput(); typedef itk::RescaleIntensityImageFilter< InternalImageType, OutputImageType > CastFilterType; typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< InternalImageType, InternalImageType > GradientFilterType; typedef itk::SigmoidImageFilter< InternalImageType, InternalImageType > SigmoidFilterType; GradientFilterType::Pointer gradientMagnitude = GradientFilterType::New(); SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New(); sigmoid->SetOutputMinimum(sig_min); sigmoid->SetOutputMaximum(sig_max); typedef itk::FastMarchingImageFilter< InternalImageType, InternalImageType > FastMarchingFilterType; FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); //const InternalImageType * inputImage = reader->GetOutput(); const InternalImageType * inputImage = val; fastMarching->SetOutputRegion( inputImage->GetBufferedRegion() ); fastMarching->SetOutputSpacing( inputImage->GetSpacing() ); fastMarching->SetOutputOrigin( inputImage->GetOrigin() ); fastMarching->SetOutputDirection( inputImage->GetDirection() ); typedef itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType, InternalImageType > GeodesicActiveContourFilterType; GeodesicActiveContourFilterType::Pointer geodesicActiveContour = GeodesicActiveContourFilterType::New(); const double propagationScaling = propagation; // Software Guide : BeginCodeSnippet geodesicActiveContour->SetPropagationScaling( propagationScaling ); geodesicActiveContour->SetCurvatureScaling(curvature); geodesicActiveContour->SetAdvectionScaling(advection); geodesicActiveContour->SetMaximumRMSError(rms); geodesicActiveContour->SetNumberOfIterations(iterations); gradientMagnitude->SetInput(val); sigmoid->SetInput( gradientMagnitude->GetOutput() ); geodesicActiveContour->SetInput( fastMarching->GetOutput() ); geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() ); thresholder->SetInput( geodesicActiveContour->GetOutput() ); //ImageOut = thresholder->GetOutput(); //writer->SetInput( thresholder->GetOutput() ); const double sigma = 0.5; gradientMagnitude->SetSigma( sigma ); sigmoid->SetAlpha( alpha ); sigmoid->SetBeta( beta ); string line; int x; int y; if (myfile.is_open()) { getline (myfile,line); string cmd = line; string arg; string::size_type pos = cmd.find(' '); if(cmd.npos != pos) { arg = cmd.substr(pos + 1); cmd = cmd.substr(0, pos); } x = atoi(cmd.c_str()); y = atoi(arg.c_str()); } typedef FastMarchingFilterType::NodeContainer NodeContainer; typedef FastMarchingFilterType::NodeType NodeType; NodeContainer::Pointer seeds = NodeContainer::New(); InternalImageType::IndexType seedPosition; seedPosition.SetElement(0,x); seedPosition.SetElement(1,y); //seedPosition.SetElement(2,(int)z); cout<<"X, Y = "<<x<<" "<<y<<endl; NodeType node; const double seedValue = - distance; node.SetValue( seedValue ); node.SetIndex( seedPosition ); seeds->Initialize(); seeds->InsertElement( 0, node ); fastMarching->SetTrialPoints( seeds ); fastMarching->SetSpeedConstant( 4.0 ); CastFilterType::Pointer caster2 = CastFilterType::New(); CastFilterType::Pointer caster3 = CastFilterType::New(); CastFilterType::Pointer caster4 = CastFilterType::New(); WriterType::Pointer writer2 = WriterType::New(); WriterType::Pointer writer3 = WriterType::New(); WriterType::Pointer writer4 = WriterType::New(); caster2->SetInput( gradientMagnitude->GetOutput() ); writer2->SetInput( caster2->GetOutput() ); writer2->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput2.tif"); caster2->SetOutputMinimum( 0 ); caster2->SetOutputMaximum( 255 ); writer2->Update(); caster3->SetInput( sigmoid->GetOutput() ); writer3->SetInput( caster3->GetOutput() ); writer3->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput3.tif"); caster3->SetOutputMinimum( 0 ); caster3->SetOutputMaximum( 255 ); writer3->Update(); caster4->SetInput( fastMarching->GetOutput() ); writer4->SetInput( caster4->GetOutput() ); writer4->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput4.tif"); caster4->SetOutputMinimum( 0 ); caster4->SetOutputMaximum( 255 ); fastMarching->SetOutputSize( reader->GetOutput()->GetBufferedRegion().GetSize() ); reader->Update(); stringstream ss2; string name2 = "/home/gustavo/temp/segmented_"; string type2 = ".tif"; if(i<9) ss2<<name2<<"00"<<(i+1)<<type2; if(i>=9 && i<99) ss2<<name2<<"0"<<(i+1)<<type2; if(i>=99) ss2<<name2<<(i+1)<<type2; string filename2 = ss2.str(); ss2.str(""); typedef itk::GradientMagnitudeImageFilter<OutputImageType, OutputImageType > GradientType; GradientType::Pointer gradient = GradientType::New(); gradient->SetInput(thresholder->GetOutput()); gradient->Update(); try { writer->SetFileName(filename2); writer->SetInput( gradient->GetOutput() ); writer->Update(); } catch( itk::ExceptionObject & excep ) { std::cerr << "Exception caught !" << std::endl; std::cerr << excep << std::endl; } std::cout << std::endl; std::cout << "Max. no. iterations: " << geodesicActiveContour->GetNumberOfIterations() << std::endl; std::cout << "Max. RMS error: " << geodesicActiveContour->GetMaximumRMSError() << std::endl; std::cout << std::endl; std::cout << "No. elpased iterations: " << geodesicActiveContour->GetElapsedIterations() << std::endl; std::cout << "RMS change: " << geodesicActiveContour->GetRMSChange() << std::endl; writer4->Update(); typedef itk::ImageFileWriter< InternalImageType > InternalWriterType; InternalWriterType::Pointer mapWriter = InternalWriterType::New(); mapWriter->SetInput( fastMarching->GetOutput() ); mapWriter->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput4.mha"); mapWriter->Update(); InternalWriterType::Pointer speedWriter = InternalWriterType::New(); speedWriter->SetInput( sigmoid->GetOutput() ); speedWriter->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput3.mha"); speedWriter->Update(); InternalWriterType::Pointer gradientWriter = InternalWriterType::New(); gradientWriter->SetInput( gradientMagnitude->GetOutput() ); gradientWriter->SetFileName("/home/gustavo/temp/GeodesicActiveContourImageFilterOutput2.mha"); gradientWriter->Update(); } myfile.close(); }
int main(int argc, const char *argv[]) { // Validate input parameters if (argc < 15) { std::cerr << "Missing parameters! Usage:" << std::endl; std::cerr << argv[0]; std::cerr << " <Read/WriteDir> <InputImg> <OutputImg> "; std::cerr << "[seedX] [seedY] [seedZ] [initDist] "; std::cerr << "[sigma] [sigmoid K1] [sigmoid K2] "; std::cerr << "[propagation] [curvature] [advection] [iterations]"; std::cerr << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 3; typedef float InputPixelType; typedef unsigned char OutputPixelType; typedef itk::Image< InputPixelType, Dimension > InputImageType; typedef itk::Image< OutputPixelType, Dimension > OutputImageType; //////////////////////////////////////////////// // 1) Read the input image typedef itk::ImageFileReader< InputImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); std::string readpath( argv[1] ); readpath.append( argv[2] ); reader->SetFileName( readpath ); reader->Update(); //////////////////////////////////////////////// // 2) Curvature anisotropic diffusion typedef itk::CurvatureAnisotropicDiffusionImageFilter< InputImageType, InputImageType > SmoothingFilterType; SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New(); smoothing->SetTimeStep(0.04); smoothing->SetNumberOfIterations(5); smoothing->SetConductanceParameter(9.0); smoothing->SetInput( reader->GetOutput() ); //////////////////////////////////////////////// // 3) Gradient magnitude recursive Gaussian const double sigma = atof(argv[8]); typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< InputImageType, InputImageType > GradientFilterType; GradientFilterType::Pointer gradientMagnitude = GradientFilterType::New(); gradientMagnitude->SetSigma( sigma ); gradientMagnitude->SetInput( smoothing->GetOutput() ); //////////////////////////////////////////////// // 4) Sigmoid mapping const double K1 = atof(argv[9]); const double K2 = atof(argv[10]); typedef itk::SigmoidImageFilter< InputImageType, InputImageType > SigmoidFilterType; SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New(); sigmoid->SetOutputMinimum(0.0); sigmoid->SetOutputMaximum(1.0); sigmoid->SetAlpha( (K2 - K1)/6 ); sigmoid->SetBeta( (K1 + K2)/2 ); sigmoid->SetInput( gradientMagnitude->GetOutput() ); //////////////////////////////////////////////// // 5) Segmentation with geodesic active contour typedef itk::FastMarchingImageFilter< InputImageType, InputImageType > FastMarchingFilterType; FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); typedef itk::GeodesicActiveContourLevelSetImageFilter< InputImageType, InputImageType > GeodesicActiveContourFilterType; GeodesicActiveContourFilterType::Pointer geodesicActiveContour = GeodesicActiveContourFilterType::New(); const double propagation = atof( argv[11] ); const double curvature = atof( argv[12] ); const double advection = atof( argv[13] ); const double iterations = atoi( argv[14] ); geodesicActiveContour->SetPropagationScaling( propagation ); geodesicActiveContour->SetCurvatureScaling( curvature ); geodesicActiveContour->SetAdvectionScaling( advection ); geodesicActiveContour->SetMaximumRMSError(0.01); geodesicActiveContour->SetNumberOfIterations( iterations ); geodesicActiveContour->SetInput( fastMarching->GetOutput() ); geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() ); //////////////////////////////////////////////// // 6) Binary thresholding typedef itk::BinaryThresholdImageFilter< InputImageType, OutputImageType > ThresholdingFilterType; ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New(); thresholder->SetLowerThreshold(-1000.0); thresholder->SetUpperThreshold(0.0); thresholder->SetOutsideValue(0); thresholder->SetInsideValue(255); thresholder->SetInput( geodesicActiveContour->GetOutput() ); //////////////////////////////////////////////// // 7) Finish setting up fast marching typedef FastMarchingFilterType::NodeContainer NodeContainer; typedef FastMarchingFilterType::NodeType NodeType; NodeContainer::Pointer seeds = NodeContainer::New(); InputImageType::IndexType seedPosition; seedPosition[0] = atoi( argv[4] ); seedPosition[1] = atoi( argv[5] ); seedPosition[2] = atoi( argv[6] ); const double initialDistance = atof( argv[7] ); const double seedValue = -initialDistance; NodeType node; node.SetValue( seedValue ); node.SetIndex( seedPosition ); seeds->Initialize(); seeds->InsertElement(0, node); fastMarching->SetTrialPoints( seeds ); fastMarching->SetSpeedConstant(1.0); fastMarching->SetOutputSize( reader->GetOutput()->GetBufferedRegion().GetSize() ); fastMarching->SetOutputRegion( reader->GetOutput()->GetBufferedRegion() ); fastMarching->SetOutputSpacing( reader->GetOutput()->GetSpacing() ); fastMarching->SetOutputOrigin( reader->GetOutput()->GetOrigin() ); //////////////////////////////////////////////// // 7) Write output image typedef itk::ImageFileWriter< OutputImageType > WriterType; WriterType::Pointer writer = WriterType::New(); std::string writepath( argv[1] ); writepath.append( argv[3] ); writer->SetFileName( writepath ); writer->SetInput( thresholder->GetOutput() ); try { writer->Update(); } catch( itk::ExceptionObject &excep ) { std::cerr << "Exception caught!" << std::endl; std::cerr << excep << std::endl; return EXIT_FAILURE; } // The following writer is used to save the output of the sigmoid mapping typedef itk::ImageFileWriter< InputImageType > InternalWriterType; InternalWriterType::Pointer speedWriter = InternalWriterType::New(); speedWriter->SetInput( sigmoid->GetOutput() ); std::string sigmoidpath( argv[1] ); speedWriter->SetFileName( sigmoidpath.append("SigmoidForGeodesic.mha")); speedWriter->Update(); return 0; }
void gradient_calc(int S_i, float* S, int i, int j, int k, float* data, int r, int s, int t, unsigned short* output_label){ //cout<<"Starting Definitions..."<<endl; //define the pixel and image types typedef float PixelType; typedef itk::Image<PixelType, 3> ImageType; typedef itk::CovariantVector< double, 3 > GradientPixelType; typedef itk::Image< GradientPixelType, 3 > GradientImageType; typedef itk::GradientRecursiveGaussianImageFilter<ImageType, GradientImageType> GradientFilterType; //Initialize a new image which will read the input label ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; start[0] = 0; start[1] = 0; start[2] = 0; ImageType::SizeType size; size[0] = k; size[1] = j; size[2] = i; ImageType::SpacingType spacing; spacing[0] = S[0]; spacing[1] = S[1]; spacing[2] = S[2]; //cout<<"X_space="<<spacing[0]<<", Y_space="<<spacing[1]<<", Z_space="<<spacing[2]<<endl; image->SetSpacing( spacing ); ImageType::RegionType region; region.SetSize( size ); region.SetIndex( start ); image->SetRegions( region ); image->Allocate(); //Create an image iterator to copy the input label into the image file typedef itk::ImageRegionIterator< ImageType > IteratorType; IteratorType it( image, image->GetRequestedRegion() ); int count = 0; while(!it.IsAtEnd()){ it.Set( data[ count ] ); ++it; count++; } //Calculate the vector gradient of the image GradientFilterType::Pointer gradientMapFilter = GradientFilterType::New(); gradientMapFilter->SetInput( image ); gradientMapFilter->SetSigma( 1.0 ); gradientMapFilter->Update(); //Creates a new image and iterator of the gradient GradientImageType::Pointer image2 = gradientMapFilter->GetOutput(); typedef itk::ImageRegionConstIterator< GradientImageType > IteratorType2; IteratorType2 it2( image2, image2->GetRequestedRegion() ); //ImageType::IndexType idx = it2.GetIndex(); //Outputs the input image to test if the input worked correctly ImageType::RegionType region2 = image2->GetLargestPossibleRegion(); long int count2 = 0; while(!it2.IsAtEnd()){ //while(count2 < (r * s * t - 1)){ float magnitude = sqrt(it2.Get()[0] * it2.Get()[0] + it2.Get()[1] * it2.Get()[1] + it2.Get()[2] * it2.Get()[2]); output_label[ count2 ] = magnitude ; count2++; ++it2; } }