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(); }
VolumeVisualizationImagePreprocessor::CTImage::Pointer VolumeVisualizationImagePreprocessor::Gaussian(CTImage::Pointer src) { VVP_INFO << "Gaussian..."; typedef itk::DiscreteGaussianImageFilter< CTImage, CTImage> GaussianFilterType; GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New(); gaussianFilter->SetInput( src ); gaussianFilter->SetVariance( 1 ); // gaussianFilter->SetMaximumError( 0.1 ); gaussianFilter->SetMaximumKernelWidth ( 8 ); gaussianFilter->UpdateLargestPossibleRegion(); CTImage::Pointer dst = gaussianFilter->GetOutput(); dst->DisconnectPipeline(); return dst; }
bool ShowSegmentationAsSmoothedSurface::ThreadedUpdateFunction() { Image::Pointer image; GetPointerParameter("Input", image); float smoothing; GetParameter("Smoothing", smoothing); float decimation; GetParameter("Decimation", decimation); float closing; GetParameter("Closing", closing); int timeNr = 0; GetParameter("TimeNr", timeNr); if (image->GetDimension() == 4) MITK_INFO << "CREATING SMOOTHED POLYGON MODEL (t = " << timeNr << ')'; else MITK_INFO << "CREATING SMOOTHED POLYGON MODEL"; MITK_INFO << " Smoothing = " << smoothing; MITK_INFO << " Decimation = " << decimation; MITK_INFO << " Closing = " << closing; Geometry3D::Pointer geometry = dynamic_cast<Geometry3D *>(image->GetGeometry()->Clone().GetPointer()); // Make ITK image out of MITK image typedef itk::Image<unsigned char, 3> CharImageType; typedef itk::Image<unsigned short, 3> ShortImageType; typedef itk::Image<float, 3> FloatImageType; if (image->GetDimension() == 4) { ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New(); imageTimeSelector->SetInput(image); imageTimeSelector->SetTimeNr(timeNr); imageTimeSelector->UpdateLargestPossibleRegion(); image = imageTimeSelector->GetOutput(0); } ImageToItk<CharImageType>::Pointer imageToItkFilter = ImageToItk<CharImageType>::New(); try { imageToItkFilter->SetInput(image); } catch (const itk::ExceptionObject &e) { // Most probably the input image type is wrong. Binary images are expected to be // >unsigned< char images. MITK_ERROR << e.GetDescription() << endl; return false; } imageToItkFilter->Update(); CharImageType::Pointer itkImage = imageToItkFilter->GetOutput(); // Get bounding box and relabel MITK_INFO << "Extracting VOI..."; int imageLabel = 1; bool roiFound = false; CharImageType::IndexType minIndex; minIndex.Fill(numeric_limits<CharImageType::IndexValueType>::max()); CharImageType::IndexType maxIndex; maxIndex.Fill(numeric_limits<CharImageType::IndexValueType>::min()); itk::ImageRegionIteratorWithIndex<CharImageType> iter(itkImage, itkImage->GetLargestPossibleRegion()); for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter) { if (iter.Get() == imageLabel) { roiFound = true; iter.Set(1); CharImageType::IndexType currentIndex = iter.GetIndex(); for (unsigned int dim = 0; dim < 3; ++dim) { minIndex[dim] = min(currentIndex[dim], minIndex[dim]); maxIndex[dim] = max(currentIndex[dim], maxIndex[dim]); } } else { iter.Set(0); } } if (!roiFound) { ProgressBar::GetInstance()->Progress(8); MITK_ERROR << "Didn't found segmentation labeled with " << imageLabel << "!" << endl; return false; } ProgressBar::GetInstance()->Progress(1); // Extract and pad bounding box typedef itk::RegionOfInterestImageFilter<CharImageType, CharImageType> ROIFilterType; ROIFilterType::Pointer roiFilter = ROIFilterType::New(); CharImageType::RegionType region; CharImageType::SizeType size; for (unsigned int dim = 0; dim < 3; ++dim) { size[dim] = maxIndex[dim] - minIndex[dim] + 1; } region.SetIndex(minIndex); region.SetSize(size); roiFilter->SetInput(itkImage); roiFilter->SetRegionOfInterest(region); roiFilter->ReleaseDataFlagOn(); roiFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::ConstantPadImageFilter<CharImageType, CharImageType> PadFilterType; PadFilterType::Pointer padFilter = PadFilterType::New(); const PadFilterType::SizeValueType pad[3] = { 10, 10, 10 }; padFilter->SetInput(roiFilter->GetOutput()); padFilter->SetConstant(0); padFilter->SetPadLowerBound(pad); padFilter->SetPadUpperBound(pad); padFilter->ReleaseDataFlagOn(); padFilter->ReleaseDataBeforeUpdateFlagOn(); padFilter->Update(); CharImageType::Pointer roiImage = padFilter->GetOutput(); roiImage->DisconnectPipeline(); roiFilter = nullptr; padFilter = nullptr; // Correct origin of real geometry (changed by cropping and padding) typedef Geometry3D::TransformType TransformType; TransformType::Pointer transform = TransformType::New(); TransformType::OutputVectorType translation; for (unsigned int dim = 0; dim < 3; ++dim) translation[dim] = (int)minIndex[dim] - (int)pad[dim]; transform->SetIdentity(); transform->Translate(translation); geometry->Compose(transform, true); ProgressBar::GetInstance()->Progress(1); // Median MITK_INFO << "Median..."; typedef itk::BinaryMedianImageFilter<CharImageType, CharImageType> MedianFilterType; MedianFilterType::Pointer medianFilter = MedianFilterType::New(); CharImageType::SizeType radius = { 0 }; medianFilter->SetRadius(radius); medianFilter->SetBackgroundValue(0); medianFilter->SetForegroundValue(1); medianFilter->SetInput(roiImage); medianFilter->ReleaseDataFlagOn(); medianFilter->ReleaseDataBeforeUpdateFlagOn(); medianFilter->Update(); ProgressBar::GetInstance()->Progress(1); // Intelligent closing MITK_INFO << "Intelligent closing..."; unsigned int surfaceRatio = (unsigned int)((1.0f - closing) * 100.0f); typedef itk::IntelligentBinaryClosingFilter<CharImageType, ShortImageType> ClosingFilterType; ClosingFilterType::Pointer closingFilter = ClosingFilterType::New(); closingFilter->SetInput(medianFilter->GetOutput()); closingFilter->ReleaseDataFlagOn(); closingFilter->ReleaseDataBeforeUpdateFlagOn(); closingFilter->SetSurfaceRatio(surfaceRatio); closingFilter->Update(); ShortImageType::Pointer closedImage = closingFilter->GetOutput(); closedImage->DisconnectPipeline(); roiImage = nullptr; medianFilter = nullptr; closingFilter = nullptr; ProgressBar::GetInstance()->Progress(1); // Gaussian blur MITK_INFO << "Gauss..."; typedef itk::BinaryThresholdImageFilter<ShortImageType, FloatImageType> BinaryThresholdToFloatFilterType; BinaryThresholdToFloatFilterType::Pointer binThresToFloatFilter = BinaryThresholdToFloatFilterType::New(); binThresToFloatFilter->SetInput(closedImage); binThresToFloatFilter->SetLowerThreshold(1); binThresToFloatFilter->SetUpperThreshold(1); binThresToFloatFilter->SetInsideValue(100); binThresToFloatFilter->SetOutsideValue(0); binThresToFloatFilter->ReleaseDataFlagOn(); binThresToFloatFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::DiscreteGaussianImageFilter<FloatImageType, FloatImageType> GaussianFilterType; // From the following line on, IntelliSense (VS 2008) is broken. Any idea how to fix it? GaussianFilterType::Pointer gaussFilter = GaussianFilterType::New(); gaussFilter->SetInput(binThresToFloatFilter->GetOutput()); gaussFilter->SetUseImageSpacing(true); gaussFilter->SetVariance(smoothing); gaussFilter->ReleaseDataFlagOn(); gaussFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> BinaryThresholdFromFloatFilterType; BinaryThresholdFromFloatFilterType::Pointer binThresFromFloatFilter = BinaryThresholdFromFloatFilterType::New(); binThresFromFloatFilter->SetInput(gaussFilter->GetOutput()); binThresFromFloatFilter->SetLowerThreshold(50); binThresFromFloatFilter->SetUpperThreshold(255); binThresFromFloatFilter->SetInsideValue(1); binThresFromFloatFilter->SetOutsideValue(0); binThresFromFloatFilter->ReleaseDataFlagOn(); binThresFromFloatFilter->ReleaseDataBeforeUpdateFlagOn(); binThresFromFloatFilter->Update(); CharImageType::Pointer blurredImage = binThresFromFloatFilter->GetOutput(); blurredImage->DisconnectPipeline(); closedImage = nullptr; binThresToFloatFilter = nullptr; gaussFilter = nullptr; ProgressBar::GetInstance()->Progress(1); // Fill holes MITK_INFO << "Filling cavities..."; typedef itk::ConnectedThresholdImageFilter<CharImageType, CharImageType> ConnectedThresholdFilterType; ConnectedThresholdFilterType::Pointer connectedThresFilter = ConnectedThresholdFilterType::New(); CharImageType::IndexType corner; corner[0] = 0; corner[1] = 0; corner[2] = 0; connectedThresFilter->SetInput(blurredImage); connectedThresFilter->SetSeed(corner); connectedThresFilter->SetLower(0); connectedThresFilter->SetUpper(0); connectedThresFilter->SetReplaceValue(2); connectedThresFilter->ReleaseDataFlagOn(); connectedThresFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::BinaryThresholdImageFilter<CharImageType, CharImageType> BinaryThresholdFilterType; BinaryThresholdFilterType::Pointer binThresFilter = BinaryThresholdFilterType::New(); binThresFilter->SetInput(connectedThresFilter->GetOutput()); binThresFilter->SetLowerThreshold(0); binThresFilter->SetUpperThreshold(0); binThresFilter->SetInsideValue(50); binThresFilter->SetOutsideValue(0); binThresFilter->ReleaseDataFlagOn(); binThresFilter->ReleaseDataBeforeUpdateFlagOn(); typedef itk::AddImageFilter<CharImageType, CharImageType, CharImageType> AddFilterType; AddFilterType::Pointer addFilter = AddFilterType::New(); addFilter->SetInput1(blurredImage); addFilter->SetInput2(binThresFilter->GetOutput()); addFilter->ReleaseDataFlagOn(); addFilter->ReleaseDataBeforeUpdateFlagOn(); addFilter->Update(); ProgressBar::GetInstance()->Progress(1); // Surface extraction MITK_INFO << "Surface extraction..."; Image::Pointer filteredImage = Image::New(); CastToMitkImage(addFilter->GetOutput(), filteredImage); filteredImage->SetGeometry(geometry); ImageToSurfaceFilter::Pointer imageToSurfaceFilter = ImageToSurfaceFilter::New(); imageToSurfaceFilter->SetInput(filteredImage); imageToSurfaceFilter->SetThreshold(50); imageToSurfaceFilter->SmoothOn(); imageToSurfaceFilter->SetDecimate(ImageToSurfaceFilter::NoDecimation); m_Surface = imageToSurfaceFilter->GetOutput(0); ProgressBar::GetInstance()->Progress(1); // Mesh decimation if (decimation > 0.0f && decimation < 1.0f) { MITK_INFO << "Quadric mesh decimation..."; vtkQuadricDecimation *quadricDecimation = vtkQuadricDecimation::New(); quadricDecimation->SetInputData(m_Surface->GetVtkPolyData()); quadricDecimation->SetTargetReduction(decimation); quadricDecimation->AttributeErrorMetricOn(); quadricDecimation->GlobalWarningDisplayOff(); quadricDecimation->Update(); vtkCleanPolyData* cleaner = vtkCleanPolyData::New(); cleaner->SetInputConnection(quadricDecimation->GetOutputPort()); cleaner->PieceInvariantOn(); cleaner->ConvertLinesToPointsOn(); cleaner->ConvertStripsToPolysOn(); cleaner->PointMergingOn(); cleaner->Update(); m_Surface->SetVtkPolyData(cleaner->GetOutput()); } ProgressBar::GetInstance()->Progress(1); // Compute Normals vtkPolyDataNormals* computeNormals = vtkPolyDataNormals::New(); computeNormals->SetInputData(m_Surface->GetVtkPolyData()); computeNormals->SetFeatureAngle(360.0f); computeNormals->FlipNormalsOff(); computeNormals->Update(); m_Surface->SetVtkPolyData(computeNormals->GetOutput()); return true; }
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 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; }
void QAngioSubstractionExtension::computeAutomateSingleImage() { QApplication::setOverrideCursor(Qt::WaitCursor); const unsigned int Dimension = 2; typedef Volume::ItkPixelType PixelType; typedef itk::Image< PixelType, Dimension > FixedImageType; typedef itk::Image< PixelType, Dimension > MovingImageType; typedef float InternalPixelType; typedef itk::Image< InternalPixelType, Dimension > InternalImageType; typedef itk::TranslationTransform< double, Dimension > TransformType; typedef itk::GradientDescentOptimizer OptimizerType; typedef itk::LinearInterpolateImageFunction< InternalImageType, double > InterpolatorType; typedef itk::ImageRegistrationMethod< InternalImageType, InternalImageType > RegistrationType; typedef itk::MutualInformationImageToImageMetric< InternalImageType, InternalImageType > MetricType; TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); MetricType::Pointer metric = MetricType::New(); registration->SetMetric(metric); metric->SetFixedImageStandardDeviation(0.4); metric->SetMovingImageStandardDeviation(0.4); metric->SetNumberOfSpatialSamples(50); typedef itk::ExtractImageFilter< Volume::ItkImageType, FixedImageType > FilterType; FilterType::Pointer extractFixedImageFilter = FilterType::New(); Volume::ItkImageType::RegionType inputRegion = m_mainVolume->getItkData()->GetLargestPossibleRegion(); Volume::ItkImageType::SizeType size = inputRegion.GetSize(); //Dividim la mida per dos per tal de quedar-nos només amb la part central // ja que si no ens registre el background size[0] = size[0] / 2; size[1] = size[1] / 2; size[2] = 0; Volume::ItkImageType::IndexType start = inputRegion.GetIndex(); const unsigned int sliceReference = m_imageSelectorSpinBox->value(); //comencem a un quart de la imatge start[0] = size[0] / 2; start[1] = size[1] / 2; start[2] = sliceReference; Volume::ItkImageType::RegionType desiredRegion; desiredRegion.SetSize(size); desiredRegion.SetIndex(start); extractFixedImageFilter->SetExtractionRegion(desiredRegion); extractFixedImageFilter->SetInput(m_mainVolume->getItkData()); extractFixedImageFilter->Update(); FilterType::Pointer extractMovingImageFilter = FilterType::New(); Volume::ItkImageType::IndexType startMoving = inputRegion.GetIndex(); const unsigned int sliceNumber = m_2DView_1->getViewer()->getCurrentSlice(); startMoving[0] = size[0] / 2; startMoving[1] = size[1] / 2; startMoving[2] = sliceNumber; Volume::ItkImageType::RegionType desiredMovingRegion; desiredMovingRegion.SetSize(size); desiredMovingRegion.SetIndex(startMoving); extractMovingImageFilter->SetExtractionRegion(desiredMovingRegion); extractMovingImageFilter->SetInput(m_mainVolume->getItkData()); extractMovingImageFilter->Update(); typedef itk::NormalizeImageFilter< FixedImageType, InternalImageType > FixedNormalizeFilterType; typedef itk::NormalizeImageFilter< MovingImageType, InternalImageType > MovingNormalizeFilterType; FixedNormalizeFilterType::Pointer fixedNormalizer = FixedNormalizeFilterType::New(); MovingNormalizeFilterType::Pointer movingNormalizer = MovingNormalizeFilterType::New(); typedef itk::DiscreteGaussianImageFilter< InternalImageType, InternalImageType > GaussianFilterType; GaussianFilterType::Pointer fixedSmoother = GaussianFilterType::New(); GaussianFilterType::Pointer movingSmoother = GaussianFilterType::New(); fixedSmoother->SetVariance(2.0); movingSmoother->SetVariance(2.0); fixedNormalizer->SetInput(extractFixedImageFilter->GetOutput()); movingNormalizer->SetInput(extractMovingImageFilter->GetOutput()); fixedSmoother->SetInput(fixedNormalizer->GetOutput()); movingSmoother->SetInput(movingNormalizer->GetOutput()); registration->SetFixedImage(fixedSmoother->GetOutput()); registration->SetMovingImage(movingSmoother->GetOutput()); fixedNormalizer->Update(); registration->SetFixedImageRegion( fixedNormalizer->GetOutput()->GetBufferedRegion()); typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); optimizer->SetLearningRate(20.0); optimizer->SetNumberOfIterations(200); optimizer->MaximizeOn(); try { registration->Update(); } catch(itk::ExceptionObject & err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return; } ParametersType finalParameters = registration->GetLastTransformParameters(); double TranslationAlongX = finalParameters[0]; double TranslationAlongY = finalParameters[1]; // Print out results // DEBUG_LOG(QString("Result = ")); DEBUG_LOG(QString(" Translation X = %1").arg(TranslationAlongX)); DEBUG_LOG(QString(" Translation Y = %1").arg(TranslationAlongY)); DEBUG_LOG(QString(" Iterations = %1").arg(optimizer->GetCurrentIteration())); DEBUG_LOG(QString(" Metric value = %1").arg(optimizer->GetValue())); double spacing[3]; m_mainVolume->getSpacing(spacing); DEBUG_LOG(QString(" Translation X (in px) = %1").arg(TranslationAlongX / spacing[0])); DEBUG_LOG(QString(" Translation Y (in px) = %1").arg(TranslationAlongY / spacing[1])); //Actualitzem les dades de la transdifference tool m_toolManager->triggerTool("TransDifferenceTool"); TransDifferenceTool* tdTool = static_cast<TransDifferenceTool*> (m_2DView_2->getViewer()->getToolProxy()->getTool("TransDifferenceTool")); if(m_tdToolData == 0){ m_tdToolData = static_cast<TransDifferenceToolData*> (tdTool->getToolData()); } if(m_tdToolData->getInputVolume() != m_mainVolume){ m_tdToolData->setInputVolume(m_mainVolume); } tdTool->setSingleDifferenceImage(TranslationAlongX / spacing[0],TranslationAlongY / spacing[1]); m_toolManager->triggerTool("SlicingTool"); /* typedef itk::Image< PixelType, Dimension > FixedImageType; typedef itk::Image< PixelType, Dimension > MovingImageType; typedef itk::TranslationTransform< double, Dimension > TransformType; typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef itk::MattesMutualInformationImageToImageMetric< FixedImageType, MovingImageType > MetricType; typedef itk:: LinearInterpolateImageFunction< MovingImageType, double > InterpolatorType; typedef itk::ImageRegistrationMethod< FixedImageType, MovingImageType > RegistrationType; MetricType::Pointer metric = MetricType::New(); TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetMetric(metric); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); metric->SetNumberOfHistogramBins(50); metric->SetNumberOfSpatialSamples(10000); typedef itk::ExtractImageFilter< Volume::ItkImageType, FixedImageType > FilterType; FilterType::Pointer extractFixedImageFilter = FilterType::New(); Volume::ItkImageType::RegionType inputRegion = m_mainVolume->getItkData()->GetLargestPossibleRegion(); Volume::ItkImageType::SizeType size = inputRegion.GetSize(); //Dividim la mida per dos per tal de quedar-nos només amb la part central // ja que si no ens registre el background size[0] = size[0] / 2; size[1] = size[1] / 2; size[2] = 0; Volume::ItkImageType::IndexType start = inputRegion.GetIndex(); const unsigned int sliceReference = m_imageSelectorSpinBox->value(); //comencem a un quart de la imatge start[0] = size[0] / 2; start[1] = size[1] / 2; start[2] = sliceReference; Volume::ItkImageType::RegionType desiredRegion; desiredRegion.SetSize(size); desiredRegion.SetIndex(start); extractFixedImageFilter->SetExtractionRegion(desiredRegion); extractFixedImageFilter->SetInput(m_mainVolume->getItkData()); extractFixedImageFilter->Update(); FilterType::Pointer extractMovingImageFilter = FilterType::New(); Volume::ItkImageType::IndexType startMoving = inputRegion.GetIndex(); const unsigned int sliceNumber = m_2DView_1->getViewer()->getCurrentSlice(); startMoving[0] = size[0] / 2; startMoving[1] = size[1] / 2; startMoving[2] = sliceNumber; Volume::ItkImageType::RegionType desiredMovingRegion; desiredMovingRegion.SetSize(size); desiredMovingRegion.SetIndex(startMoving); extractMovingImageFilter->SetExtractionRegion(desiredMovingRegion); extractMovingImageFilter->SetInput(m_mainVolume->getItkData()); extractMovingImageFilter->Update(); registration->SetFixedImage(extractFixedImageFilter->GetOutput()); registration->SetMovingImage(extractMovingImageFilter->GetOutput()); typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); //Potser seria millor posar la transformada que té actualment initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); optimizer->SetMaximumStepLength(4.00); optimizer->SetMinimumStepLength(0.005); optimizer->SetNumberOfIterations(200); try { registration->StartRegistration(); } catch(itk::ExceptionObject & err) { DEBUG_LOG(QString("ExceptionObject caught !")); std::cout<<err<<std::endl; return; } ParametersType finalParameters = registration->GetLastTransformParameters(); const double TranslationAlongX = finalParameters[0]; const double TranslationAlongY = finalParameters[1]; const unsigned int numberOfIterations = optimizer->GetCurrentIteration(); const double bestValue = optimizer->GetValue(); DEBUG_LOG(QString("Result = ")); DEBUG_LOG(QString(" Translation X = %1").arg(TranslationAlongX)); DEBUG_LOG(QString(" Translation Y = %1").arg(TranslationAlongY)); DEBUG_LOG(QString(" Iterations = %1").arg(numberOfIterations)); DEBUG_LOG(QString(" Metric value = %1").arg(bestValue)); typedef unsigned char OutputPixelType; typedef itk::Image< OutputPixelType, Dimension > OutputImageType; typedef itk::RescaleIntensityImageFilter< FixedImageType, FixedImageType > RescaleFilterType; typedef itk::ResampleImageFilter< FixedImageType, FixedImageType > ResampleFilterType; typedef itk::CastImageFilter< FixedImageType, OutputImageType > CastFilterType; typedef itk::ImageFileWriter< OutputImageType > WriterType; WriterType::Pointer writer = WriterType::New(); CastFilterType::Pointer caster = CastFilterType::New(); ResampleFilterType::Pointer resample = ResampleFilterType::New(); RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); TransformType::Pointer finalTransform = TransformType::New(); finalTransform->SetParameters(finalParameters); resample->SetTransform(finalTransform); resample->SetSize(extractMovingImageFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); resample->SetOutputOrigin(extractMovingImageFilter->GetOutput()->GetOrigin()); resample->SetOutputSpacing(extractMovingImageFilter->GetOutput()->GetSpacing()); resample->SetDefaultPixelValue(100); writer->SetFileName("prova.jpg"); rescaler->SetInput(extractMovingImageFilter->GetOutput()); resample->SetInput(rescaler->GetOutput()); caster->SetInput(resample->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); */ QApplication::restoreOverrideCursor(); }