bool VolumeProcess::RunGaussianSmoothing(float varX, float varY, float varZ, float maxErr) { //by xiao liang typedef itk::DiscreteGaussianImageFilter< ImageType, FloatImageType3D > GaussianFilterType; GaussianFilterType::Pointer GaussianFilter = GaussianFilterType::New(); GaussianFilter->SetInput(m_outputImage); //GaussianFilter->SetFilterDimensionality(3); GaussianFilterType::ArrayType maxErrTypeValue; maxErrTypeValue.Fill(maxErr); GaussianFilter->SetMaximumError( maxErrTypeValue ); GaussianFilterType::ArrayType variance; variance[0] = varX; variance[1] = varY; variance[2] = varZ; GaussianFilter->SetVariance(variance); //GaussianFilter->SetMaximumKernelWidth(maxKernalWidth); try { GaussianFilter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl ; return false; } m_outputImage = RescaleFloatToImageType(GaussianFilter->GetOutput()); if(debug) std::cerr << "GaussianFilter Filter Done" << std::endl; return true; }
ImageType::Pointer SBFilterUtils::GaussianSmoothImage(ImageType::Pointer image, float variance) { GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput(image); gaussianFilter->SetVariance(variance); gaussianFilter->Update(); CastFilterType::Pointer castFilter = CastFilterType::New(); castFilter->SetInput(gaussianFilter->GetOutput()); castFilter->Update(); return castFilter->GetOutput(); }
int main(int argc, char* argv[]) { mitkCommandLineParser parser; parser.setTitle("DmriDenoising"); parser.setCategory("Preprocessing Tools"); parser.setDescription("dMRI denoising tool"); parser.setContributor("MIC"); parser.setArgumentPrefix("--", "-"); parser.beginGroup("1. Mandatory arguments:"); parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "input image", us::Any(), false, false, false, mitkCommandLineParser::Input); parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false, false, false, mitkCommandLineParser::Output); parser.addArgument("type", "", mitkCommandLineParser::Int, "Type:", "0 (TotalVariation), 1 (Gauss), 2 (NLM)", 0); parser.endGroup(); parser.beginGroup("2. Total variation parameters:"); parser.addArgument("tv_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 1); parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "", 0.1); parser.endGroup(); parser.beginGroup("3. Gauss parameters:"); parser.addArgument("variance", "", mitkCommandLineParser::Float, "Variance:", "", 1.0); parser.endGroup(); parser.beginGroup("4. NLM parameters:"); parser.addArgument("nlm_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 4); parser.addArgument("sampling_radius", "", mitkCommandLineParser::Int, "Sampling radius:", "", 4); parser.addArgument("patch_radius", "", mitkCommandLineParser::Int, "Patch radius:", "", 1); parser.addArgument("num_patches", "", mitkCommandLineParser::Int, "Num. patches:", "", 10); parser.endGroup(); std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv); if (parsedArgs.size()==0) return EXIT_FAILURE; // mandatory arguments std::string imageName = us::any_cast<std::string>(parsedArgs["i"]); std::string outImage = us::any_cast<std::string>(parsedArgs["o"]); int type = 0; if (parsedArgs.count("type")) type = us::any_cast<int>(parsedArgs["type"]); int tv_iterations = 1; if (parsedArgs.count("tv_iterations")) tv_iterations = us::any_cast<int>(parsedArgs["tv_iterations"]); float lambda = 0.1; if (parsedArgs.count("lambda")) lambda = us::any_cast<float>(parsedArgs["lambda"]); float variance = 1.0; if (parsedArgs.count("variance")) variance = us::any_cast<float>(parsedArgs["variance"]); int nlm_iterations = 4; if (parsedArgs.count("nlm_iterations")) nlm_iterations = us::any_cast<int>(parsedArgs["nlm_iterations"]); int sampling_radius = 4; if (parsedArgs.count("sampling_radius")) sampling_radius = us::any_cast<int>(parsedArgs["sampling_radius"]); int patch_radius = 1; if (parsedArgs.count("patch_radius")) patch_radius = us::any_cast<int>(parsedArgs["patch_radius"]); int num_patches = 10; if (parsedArgs.count("num_patches")) num_patches = us::any_cast<int>(parsedArgs["num_patches"]); try { mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {}); mitk::Image::Pointer input_image = mitk::IOUtil::Load<mitk::Image>(imageName, &functor); typedef short DiffusionPixelType; typedef itk::VectorImage<DiffusionPixelType, 3> DwiImageType; typedef itk::Image<DiffusionPixelType, 3> DwiVolumeType; typedef itk::DiscreteGaussianImageFilter < DwiVolumeType, DwiVolumeType > GaussianFilterType; typedef itk::PatchBasedDenoisingImageFilter < DwiVolumeType, DwiVolumeType > NlmFilterType; typedef itk::VectorImageToImageFilter < DiffusionPixelType > ExtractFilterType; typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> > ComposeFilterType; if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(input_image)) mitkThrow() << "Input is not a diffusion-weighted image!"; DwiImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(input_image); mitk::Image::Pointer denoised_image = nullptr; switch (type) { case 0: { ComposeFilterType::Pointer composer = ComposeFilterType::New(); for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i) { ExtractFilterType::Pointer extractor = ExtractFilterType::New(); extractor->SetInput( itkVectorImagePointer ); extractor->SetIndex( i ); extractor->Update(); DwiVolumeType::Pointer gradient_volume = extractor->GetOutput(); itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::Pointer filter = itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::New(); filter->SetInput(gradient_volume); filter->SetLambda(lambda); filter->SetNumberIterations(tv_iterations); filter->Update(); composer->SetInput(i, filter->GetOutput()); } composer->Update(); denoised_image = mitk::GrabItkImageMemory(composer->GetOutput()); break; } case 1: { ExtractFilterType::Pointer extractor = ExtractFilterType::New(); extractor->SetInput( itkVectorImagePointer ); ComposeFilterType::Pointer composer = ComposeFilterType::New(); for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i) { extractor->SetIndex(i); extractor->Update(); GaussianFilterType::Pointer filter = GaussianFilterType::New(); filter->SetVariance(variance); filter->SetInput(extractor->GetOutput()); filter->Update(); composer->SetInput(i, filter->GetOutput()); } composer->Update(); denoised_image = mitk::GrabItkImageMemory(composer->GetOutput()); break; } case 2: { typedef itk::Statistics::GaussianRandomSpatialNeighborSubsampler< NlmFilterType::PatchSampleType, DwiVolumeType::RegionType > SamplerType; // sampling the image to find similar patches SamplerType::Pointer sampler = SamplerType::New(); sampler->SetRadius( sampling_radius ); sampler->SetVariance( sampling_radius*sampling_radius ); sampler->SetNumberOfResultsRequested( num_patches ); MITK_INFO << "Starting NLM denoising"; ExtractFilterType::Pointer extractor = ExtractFilterType::New(); extractor->SetInput( itkVectorImagePointer ); ComposeFilterType::Pointer composer = ComposeFilterType::New(); for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i) { extractor->SetIndex(i); extractor->Update(); NlmFilterType::Pointer filter = NlmFilterType::New(); filter->SetInput(extractor->GetOutput()); filter->SetPatchRadius(patch_radius); filter->SetNoiseModel(NlmFilterType::RICIAN); filter->UseSmoothDiscPatchWeightsOn(); filter->UseFastTensorComputationsOn(); filter->SetNumberOfIterations(nlm_iterations); filter->SetSmoothingWeight( 1 ); filter->SetKernelBandwidthEstimation(true); filter->SetSampler( sampler ); filter->Update(); composer->SetInput(i, filter->GetOutput()); MITK_INFO << "Gradient " << i << " finished"; } composer->Update(); denoised_image = mitk::GrabItkImageMemory(composer->GetOutput()); break; } } mitk::DiffusionPropertyHelper::SetGradientContainer(denoised_image, mitk::DiffusionPropertyHelper::GetGradientContainer(input_image)); mitk::DiffusionPropertyHelper::SetReferenceBValue(denoised_image, mitk::DiffusionPropertyHelper::GetReferenceBValue(input_image)); mitk::DiffusionPropertyHelper::InitializeImage( denoised_image ); std::string ext = itksys::SystemTools::GetFilenameExtension(outImage); if (ext==".nii" || ext==".nii.gz") mitk::IOUtil::Save(denoised_image, "DWI_NIFTI", outImage); else mitk::IOUtil::Save(denoised_image, outImage); } catch (itk::ExceptionObject e) { std::cout << e; return EXIT_FAILURE; } catch (std::exception e) { std::cout << e.what(); return EXIT_FAILURE; } catch (...) { std::cout << "ERROR!?!"; return EXIT_FAILURE; } return EXIT_SUCCESS; }
void WholeCellSeg::RealBoundaries(){ int size1=cyt_im_inp->GetLargestPossibleRegion().GetSize()[0]; int size2=cyt_im_inp->GetLargestPossibleRegion().GetSize()[1]; typedef itk::SmoothingRecursiveGaussianImageFilter< UShortImageType, UShortImageType > GaussianFilterType; typedef itk::GradientMagnitudeImageFilter< UShortImageType, UShortImageType > GradientMagnitudeType; typedef itk::RescaleIntensityImageFilter< UShortImageType, FltImageType > RescaleUSFltType; typedef itk::CastImageFilter< UShortImageType, IntImageType > CastUSIntType; typedef itk::CastImageFilter< IntImageType, UShortImageType > CastIntUSType; typedef itk::ImageRegionIteratorWithIndex< IntImageType > IteratorType1; typedef itk::ImageRegionConstIterator< FltImageType > ConstIteratorType1; typedef itk::ImageRegionConstIterator< UShortImageType > ConstIteratorType; typedef itk::MorphologicalWatershedFromMarkersImageFilter< IntImageType, IntImageType > WatershedFilterType; //Get gradient image from cytoplasm image GaussianFilterType::Pointer gaussianfilter = GaussianFilterType::New(); gaussianfilter->SetSigma( 1.25 ); gaussianfilter->SetInput( cyt_im_inp ); gaussianfilter->Update(); GradientMagnitudeType::Pointer gradmagfilter = GradientMagnitudeType::New(); gradmagfilter->SetInput( gaussianfilter->GetOutput() ); gradmagfilter->Update(); //Rescale image RescaleUSFltType::Pointer rescaleusflt = RescaleUSFltType::New(); rescaleusflt->SetOutputMaximum( scaling ); rescaleusflt->SetOutputMinimum( 1 ); rescaleusflt->SetInput( gradmagfilter->GetOutput() ); rescaleusflt->Update(); //Get the rescaled gradient image from ITK into an array of known size and indexing system float *INP_IM_2D; FltImageType::Pointer grad_img = FltImageType::New(); grad_img = rescaleusflt->GetOutput(); INP_IM_2D = (float *) malloc (size1*size2*sizeof(float)); if ( INP_IM_2D == NULL ){ std::cerr << "Unable to allocate memory for 2D Gradient Image"; return; } ConstIteratorType1 pix_buf( grad_img, grad_img->GetRequestedRegion() ); itk::IndexValueType ind=0; for ( pix_buf.GoToBegin(); !pix_buf.IsAtEnd(); ++pix_buf, ++ind ) INP_IM_2D[ind] = ( pix_buf.Get() ); //int testing=0; if( use_mem_img ){ GaussianFilterType::Pointer gaussianfilter1 = GaussianFilterType::New(); gaussianfilter1->SetSigma( 1.25 ); gaussianfilter1->SetInput( mem_im_inp ); gaussianfilter1->Update(); GradientMagnitudeType::Pointer gradmagfilter1 = GradientMagnitudeType::New(); gradmagfilter1->SetInput( gaussianfilter1->GetOutput() ); gradmagfilter1->Update(); RescaleUSFltType::Pointer rescaleusflt1 = RescaleUSFltType::New(); rescaleusflt1->SetOutputMaximum( scaling ); rescaleusflt1->SetOutputMinimum( 1 ); rescaleusflt1->SetInput( gradmagfilter1->GetOutput() ); rescaleusflt1->Update(); FltImageType::Pointer grad_img1 = FltImageType::New(); grad_img1 = rescaleusflt1->GetOutput(); float *INP_IM_2D1; INP_IM_2D1 = (float *) malloc (size1*size2*sizeof(float)); if ( INP_IM_2D1 == NULL ){ std::cerr << "Unable to allocate memory for 2D Membrane Image"; return; } ConstIteratorType1 pix_buf2( grad_img1, grad_img1->GetRequestedRegion() ); ind=0; for ( pix_buf2.GoToBegin(); !pix_buf2.IsAtEnd(); ++pix_buf2, ++ind ) INP_IM_2D1[ind]=(pix_buf2.Get()); for(itk::SizeValueType j=0; j<size2; j++) for(itk::SizeValueType i=0; i<size1; i++) inp_im_2D(i,j) = (inp_im_2D(i,j)/mem_scaling)*(inp_im_2D1(i,j)*mem_scaling); free( INP_IM_2D1 ); } //Get the nucleus label image from ITK into an array of known size and indexing system unsigned short *NUC_IM; NUC_IM = (unsigned short *) malloc (size1*size2*sizeof(unsigned short)); if ( NUC_IM == NULL ){ std::cerr << "Unable to allocate memory for Nucleus Label Image"; return; } ConstIteratorType pix_buf2( nuclab_inp, nuclab_inp->GetRequestedRegion() ); ind=0; for ( pix_buf2.GoToBegin(); !pix_buf2.IsAtEnd(); ++pix_buf2, ++ind ) NUC_IM[ind]=(pix_buf2.Get()); //allocate memory for the gradient weighted distance map float *GRAD_IMW; GRAD_IMW = (float *) malloc ((size1+2)*(size2+2)*sizeof(float)); if ( GRAD_IMW == NULL ){ std::cerr << "Unable to allocate memory for Gradient Weighted Distance Image"; return; } //Create Gradient Weighted Distance Map float flt_mini = -1*FLT_MAX; for(itk::SizeValueType i=0; i<size1; i++) for(itk::SizeValueType j=0; j<size2; j++){ if(!nuc_im(i,j)) grad_imw(i+1,j+1) = FLT_MAX; else grad_imw(i+1,j+1)=0; } for(itk::SizeValueType i=0; i<size1; i++) for(itk::SizeValueType j=0; j<size2; j++) if(!BIN_Image(i,j)) grad_imw(i+1,j+1)=flt_mini; free( NUC_IM ); free( bin_Image ); for(itk::SizeValueType i=0; i<(size1+2); i++){ grad_imw(i,0)=flt_mini; grad_imw(i,size2+1)=flt_mini; } for(itk::SizeValueType i=0; i<(size2+2); i++){ grad_imw(0,i)=flt_mini; grad_imw(size1+1,i)=flt_mini; } int ok; ok = gradient_enhanced_distance_map( INP_IM_2D, GRAD_IMW, size1, size2); free( INP_IM_2D ); //Getting gradient weighted distance map into ITK array IntImageType::Pointer image2; image2 = IntImageType::New(); IntImageType::PointType origint; origint[0] = 0; origint[1] = 0; image2->SetOrigin( origint ); IntImageType::IndexType startt; startt[0] = 0; // first index on X startt[1] = 0; // first index on Y IntImageType::SizeType sizet; sizet[0] = size1; // size along X sizet[1] = size2; // size along Y IntImageType::RegionType regiont; regiont.SetSize( sizet ); regiont.SetIndex( startt ); image2->SetRegions( regiont ); image2->Allocate(); image2->FillBuffer(0); image2->Update(); //copy the output image into the ITK image IteratorType1 iteratort(image2,image2->GetRequestedRegion()); for(itk::SizeValueType j=0; j<size2; j++){ for(itk::SizeValueType i=0; i<size1; i++){ iteratort.Set(grad_imw(i+1,j+1)); ++iteratort; } } free( GRAD_IMW ); CastUSIntType::Pointer castUSIntfilter = CastUSIntType::New(); castUSIntfilter->SetInput( nuclab_inp ); castUSIntfilter->Update(); IntImageType::Pointer nuclab_inp_int = IntImageType::New(); nuclab_inp_int = castUSIntfilter->GetOutput(); //Seeded watershed to get the cytoplasm regions WatershedFilterType::Pointer watershedfilter = WatershedFilterType::New(); watershedfilter->SetInput1( image2 ); watershedfilter->SetInput2( nuclab_inp_int ); watershedfilter->SetMarkWatershedLine( 1 ); watershedfilter->Update(); CastIntUSType::Pointer castIntUSfilter = CastIntUSType::New(); castIntUSfilter->SetInput( watershedfilter->GetOutput() ); castIntUSfilter->Update(); seg_im_out = castIntUSfilter->GetOutput(); //Write the output for testing /* IteratorType1 pix_bufed33( image2, image2->GetRequestedRegion() ); pix_bufed33.GoToBegin(); while( !pix_bufed33.IsAtEnd() ){ if( 0 > pix_bufed33.Get() ) pix_bufed33.Set(0); ++pix_bufed33; } typedef itk::RescaleIntensityImageFilter< IntImageType, UShortImageType > RescaleIntIOType; RescaleIntIOType::Pointer RescaleIntIO1 = RescaleIntIOType::New(); RescaleIntIO1->SetOutputMaximum( USHRT_MAX ); RescaleIntIO1->SetOutputMinimum( 0 ); RescaleIntIO1->SetInput( image2 ); //watershedfilter->GetOutput() image1 RescaleIntIO1->Update(); typedef itk::ImageFileWriter< UShortImageType > WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName( "grad_wts.tif" ); writer->SetInput( RescaleIntIO1->GetOutput() );//RescaleIntIO1--finalO/P writer->Update(); */ //Get Array into IDL /* IntImageType::Pointer image_fin = IntImageType::New(); image_fin = watershedfilter->GetOutput(); ConstIteratorType3 pix_bufed3( image_fin, image_fin->GetRequestedRegion() ); pix_bufed3.GoToBegin(); for(int j=size2-1; j>=0; j--) for(int i=0; i<size1; i++){ OP(i,j)=(pix_bufed3.Get()); ++pix_bufed3; } */ if( !remove_small_objs ) seg_done = 1; }
unsigned int Initialisation::houghTransformCircles(ImageType2D* im, unsigned int numberOfCircles, double** center_result, double* radius_result, double* accumulator_result, double meanRadius, double valPrint) { MinMaxCalculatorType::Pointer minMaxCalculator = MinMaxCalculatorType::New(); minMaxCalculator->SetImage(im); minMaxCalculator->ComputeMaximum(); minMaxCalculator->ComputeMinimum(); ImageType2D::PixelType maxIm = minMaxCalculator->GetMaximum(), minIm = minMaxCalculator->GetMinimum(); double val_Print = maxIm; double min_radius = meanRadius-3.0; if (min_radius < 0) min_radius = 0; HoughCirclesFilter::Pointer houghfilter = HoughCirclesFilter::New(); houghfilter->SetInput(im); houghfilter->SetMinimumRadius(min_radius); houghfilter->SetMaximumRadius(meanRadius+3.0); houghfilter->SetSigmaGradient(2); houghfilter->SetGradientFactor(valPrint*typeImageFactor_); houghfilter->SetSweepAngle(M_PI/180.0*5.0); houghfilter->SetThreshold((maxIm-minIm)/20.0); houghfilter->Update(); const double nPI = 4.0 * vcl_atan( 1.0 ); ImageType2D::IndexType index; ImageType2D::Pointer m_Accumulator= houghfilter->GetOutput(); ImageType2D::Pointer m_RadiusImage= houghfilter->GetRadiusImage(); /** Blur the accumulator in order to find the maximum */ ImageType2D::Pointer m_PostProcessImage = ImageType2D::New(); GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput(m_Accumulator); double variance[2]; variance[0]=10; variance[1]=10; gaussianFilter->SetVariance(variance); gaussianFilter->SetMaximumError(.01f); gaussianFilter->Update(); m_PostProcessImage = gaussianFilter->GetOutput(); ImageType2D::SizeType bound = m_PostProcessImage->GetLargestPossibleRegion().GetSize(); itk::ImageRegionIterator<ImageType2D> it_output(im,im->GetLargestPossibleRegion()); itk::ImageRegionIterator<ImageType2D> it_input(m_PostProcessImage,m_PostProcessImage->GetLargestPossibleRegion()); /** Set the disc ratio */ double discRatio = 1.1; /** Search for maxima */ unsigned int circles=0, maxIteration=100, it=0; do{ it++; minMaxCalculator->SetImage(m_PostProcessImage); minMaxCalculator->ComputeMaximum(); ImageType2D::PixelType max = minMaxCalculator->GetMaximum(); it_output.GoToBegin(); for(it_input.GoToBegin();!it_input.IsAtEnd();++it_input) { if(it_input.Get() == max) { it_output.Set(val_Print); index = it_output.GetIndex(); double radius2 = m_RadiusImage->GetPixel(index); if (index[0]!=0 && index[0]!=bound[0]-1 && index[1]!=0 && index[1]!=bound[1]-1) { center_result[circles][0] = it_output.GetIndex()[0]; center_result[circles][1] = it_output.GetIndex()[1]; radius_result[circles] = radius2; accumulator_result[circles] = m_PostProcessImage->GetPixel(index); // Draw the circle for(double angle = 0; angle <= 2 * nPI; angle += nPI / 1000) { index[0] = (long int)(it_output.GetIndex()[0] + radius2 * cos(angle)); index[1] = (long int)(it_output.GetIndex()[1] + radius2 * sin(angle)); if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1]) im->SetPixel(index,val_Print); // Remove the maximum from the accumulator for(double length = 0; length < discRatio*radius2;length+=1) { index[0] = (long int)(it_output.GetIndex()[0] + length * cos(angle)); index[1] = (long int)(it_output.GetIndex()[1] + length* sin(angle)); if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1]) m_PostProcessImage->SetPixel(index,0); } } circles++; if(circles == numberOfCircles) break; } else { // Draw the circle for(double angle = 0; angle <= 2 * nPI; angle += nPI / 1000) { // Remove the maximum from the accumulator for(double length = 0; length < discRatio*radius2;length+=1) { index[0] = (long int)(it_output.GetIndex()[0] + length * cos(angle)); index[1] = (long int)(it_output.GetIndex()[1] + length* sin(angle)); if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1]) m_PostProcessImage->SetPixel(index,0); } } } minMaxCalculator->SetImage(m_PostProcessImage); minMaxCalculator->ComputeMaximum(); max = minMaxCalculator->GetMaximum(); } ++it_output; } } while(circles<numberOfCircles && it<=maxIteration); return circles; }