void ComputeMaskedIsophotesInRegion(const FloatScalarImageType* const image, const Mask* const mask, const itk::ImageRegion<2>& region, FloatVector2ImageType* const outputIsophotes) { //Helpers::WriteImageConditional<FloatScalarImageType>(image, "Debug/ComputeMaskedIsophotes.luminance.mha", this->DebugImages); FloatVector2ImageType::Pointer gradient = FloatVector2ImageType::New(); ITKHelpers::InitializeImage<FloatVector2ImageType>(gradient, image->GetLargestPossibleRegion()); Derivatives::MaskedGradientInRegion<FloatScalarImageType>(image, mask, region, gradient); //Helpers::DebugWriteImageConditional<FloatVector2ImageType>(gradient, "Debug/ComputeMaskedIsophotes.gradient.mha", this->DebugImages); //Helpers::Write2DVectorImage(gradient, "Debug/ComputeMaskedIsophotes.gradient.mha"); // Rotate the gradient 90 degrees to obtain isophotes from gradient typedef itk::UnaryFunctorImageFilter<FloatVector2ImageType, FloatVector2ImageType, RotateVectors<FloatVector2ImageType::PixelType, FloatVector2ImageType::PixelType> > FilterType; FilterType::Pointer rotateFilter = FilterType::New(); rotateFilter->SetInput(gradient); rotateFilter->Update(); //Helpers::DebugWriteImageConditional<FloatVector2ImageType>(rotateFilter->GetOutput(), "Debug/ComputeMaskedIsophotes.Isophotes.mha", this->DebugImages); //Helpers::Write2DVectorImage(rotateFilter->GetOutput(), "Debug/ComputeMaskedIsophotes.Isophotes.mha"); ITKHelpers::CopyRegion<FloatVector2ImageType>(rotateFilter->GetOutput(), outputIsophotes, region, region); }
int main(int argc, char* argv[]) { typedef itk::Image<float, 3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; const char* filenamereader = "/Users/Fabian/Documents/Pruebas/Prueba ITK/Archivo Binary/m1.mhd"; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName(filenamereader); reader->Update(); typedef itk::ScalarToFractalImageFilter<ImageType,ImageType> FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput(reader->GetOutput()); FilterType::RadiusType radius; radius.Fill(3); filter->SetNeighborhoodRadius(radius); filter->Update(); // typedef itk::ImageFileWriter<ImageType> WriterType; // const char* filenamewriter = "xy14_filter.bmp"; // WriterType::Pointer writer = WriterType::New(); // writer->SetFileName(filenamewriter); // writer->SetInput(filter->GetOutput()); // writer->Update(); return 0; }
void Preprocess::MedianHoleFilling(int radiusX, int radiusY, int radiusZ) { int size3 = myImg->GetLargestPossibleRegion().GetSize()[2]; if(size3==1) radiusZ = 0; ImageType3D::SizeType radius; radius[0] = radiusX; radius[1] = radiusY; radius[2] = radiusZ; typedef itk::BinaryMedianImageFilter< ImageType3D, ImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetRadius(radius); filter->SetInput(myImg); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl ; return; } myImg = filter->GetOutput(); }
VolumeVisualizationImagePreprocessor::BinImage::Pointer VolumeVisualizationImagePreprocessor::Crop(VolumeVisualizationImagePreprocessor::BinImage::Pointer src ) { VVP_INFO << "Cropping 8bit..."; typedef itk::RegionOfInterestImageFilter<BinImage,BinImage> FilterType; FilterType::Pointer cropFilter = FilterType::New(); cropFilter->SetInput( src ); BinImage::RegionType region; BinImage::SizeType size; BinImage::IndexType index; index.SetElement(0,m_MinX); index.SetElement(1,m_MinY); index.SetElement(2,m_MinZ); size.SetElement(0,m_MaxX-m_MinX+1); size.SetElement(1,m_MaxY-m_MinY+1); size.SetElement(2,m_MaxZ-m_MinZ+1); region.SetIndex(index); region.SetSize(size); cropFilter->SetRegionOfInterest(region); cropFilter->Update(); BinImage::Pointer dst = cropFilter->GetOutput(); dst->DisconnectPipeline(); return dst; }
void QmitkTensorReconstructionView::TensorsToQbi() { for (int i=0; i<m_TensorImages->size(); i++) { mitk::DataNode::Pointer tensorImageNode = m_TensorImages->at(i); MITK_INFO << "starting Q-Ball estimation"; typedef float TTensorPixelType; typedef itk::DiffusionTensor3D< TTensorPixelType > TensorPixelType; typedef itk::Image< TensorPixelType, 3 > TensorImageType; TensorImageType::Pointer itkvol = TensorImageType::New(); mitk::CastToItkImage<TensorImageType>(dynamic_cast<mitk::TensorImage*>(tensorImageNode->GetData()), itkvol); typedef itk::TensorImageToQBallImageFilter< TTensorPixelType, TTensorPixelType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( itkvol ); filter->Update(); typedef itk::Vector<TTensorPixelType,QBALL_ODFSIZE> OutputPixelType; typedef itk::Image<OutputPixelType,3> OutputImageType; mitk::QBallImage::Pointer image = mitk::QBallImage::New(); OutputImageType::Pointer outimg = filter->GetOutput(); image->InitializeByItk( outimg.GetPointer() ); image->SetVolume( outimg->GetBufferPointer() ); mitk::DataNode::Pointer node = mitk::DataNode::New(); node->SetData( image ); QString newname; newname = newname.append(tensorImageNode->GetName().c_str()); newname = newname.append("_qbi"); node->SetName(newname.toAscii()); GetDefaultDataStorage()->Add(node); } }
void Preprocess::MedianFilter( int radiusX, int radiusY, int radiusZ) { int size3 = myImg->GetLargestPossibleRegion().GetSize()[2]; if(size3==1) radiusZ = 0; ImageType3D::SizeType radius; radius[0] = radiusX; // radius along x radius[1] = radiusY; // radius along y radius[2] = radiusZ; // radius along y typedef itk::MedianImageFilter<ImageType3D,ImageType3D> FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetRadius( radius ); filter->SetInput(myImg); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "Exception caught: " << err << std::endl; } myImg = filter->GetOutput(); }
void QmitkOdfMaximaExtractionView::ConvertPeaksFromMrtrix() { if (m_ImageNodes.empty()) return; typedef itk::Image< float, 4 > ItkImageType; typedef itk::MrtrixPeakImageConverter< float > FilterType; FilterType::Pointer filter = FilterType::New(); // cast to itk mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData()); mitk::Geometry3D::Pointer geom = mitkImg->GetGeometry(); typedef mitk::ImageToItk< FilterType::InputImageType > CasterType; CasterType::Pointer caster = CasterType::New(); caster->SetInput(mitkImg); caster->Update(); FilterType::InputImageType::Pointer itkImg = caster->GetOutput(); filter->SetInputImage(itkImg); filter->GenerateData(); mitk::Vector3D outImageSpacing = geom->GetSpacing(); float maxSpacing = 1; if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2]) maxSpacing = outImageSpacing[0]; else if (outImageSpacing[1] > outImageSpacing[2]) maxSpacing = outImageSpacing[1]; else maxSpacing = outImageSpacing[2]; mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle(); directions->SetGeometry(geom); DataNode::Pointer node = DataNode::New(); node->SetData(directions); QString name(m_ImageNodes.at(0)->GetName().c_str()); name += "_VectorField"; node->SetName(name.toStdString().c_str()); node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing)); node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false)); GetDataStorage()->Add(node); typedef FilterType::DirectionImageContainerType DirectionImageContainerType; DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer(); for (int i=0; i<container->Size(); i++) { ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i); mitk::Image::Pointer img = mitk::Image::New(); img->InitializeByItk( itkImg.GetPointer() ); img->SetVolume( itkImg->GetBufferPointer() ); DataNode::Pointer node = DataNode::New(); node->SetData(img); QString name(m_ImageNodes.at(0)->GetName().c_str()); name += "_Direction"; name += QString::number(i+1); node->SetName(name.toStdString().c_str()); GetDataStorage()->Add(node); } }
void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName) { typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType; // filter input parameter const mitk::DiffusionImage<DiffusionPixelType>::BValueMap &originalShellMap = ImPtr->GetBValueMap(); const mitk::DiffusionImage<DiffusionPixelType>::ImageType *vectorImage = ImPtr->GetVectorImage(); const mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType::Pointer gradientContainer = ImPtr->GetDirections(); const unsigned int &bValue = ImPtr->GetReferenceBValue(); mitk::DataNode::Pointer imageNode = 0; // filter call FilterType::Pointer filter = FilterType::New(); filter->SetInput(vectorImage); filter->SetOriginalGradientDirections(gradientContainer); filter->SetOriginalBValueMap(originalShellMap); filter->SetOriginalBValue(bValue); filter->SetFunctor(functor); filter->Update(); // create new DWI image mitk::DiffusionImage<DiffusionPixelType>::Pointer outImage = mitk::DiffusionImage<DiffusionPixelType>::New(); outImage->SetVectorImage( filter->GetOutput() ); outImage->SetReferenceBValue( m_Controls->m_targetBValueSpinBox->value() ); outImage->SetDirections( filter->GetTargetGradientDirections() ); outImage->InitializeFromVectorImage(); imageNode = mitk::DataNode::New(); imageNode->SetData( outImage ); imageNode->SetName(imageName.toStdString().c_str()); GetDefaultDataStorage()->Add(imageNode); if(m_Controls->m_OutputRMSErrorImage->isChecked()){ // create new Error image FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage(); mitk::Image::Pointer mitkErrImage = mitk::Image::New(); mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage); mitkErrImage->SetVolume(errImage->GetBufferPointer()); imageNode = mitk::DataNode::New(); imageNode->SetData( mitkErrImage ); imageNode->SetName((imageName+"_Error").toStdString().c_str()); GetDefaultDataStorage()->Add(imageNode); } }
void mitk::OtsuTool3D::UpdateBinaryPreview(int regionID) { m_MultiLabelResultNode->SetVisibility(false); //pixel with regionID -> binary image const unsigned short dim = 3; typedef unsigned char PixelType; typedef itk::Image< PixelType, dim > InputImageType; typedef itk::Image< PixelType, dim > OutputImageType; typedef itk::BinaryThresholdImageFilter< InputImageType, OutputImageType > FilterType; FilterType::Pointer filter = FilterType::New(); InputImageType::Pointer itkImage; mitk::Image::Pointer multiLabelSegmentation = dynamic_cast<mitk::Image*>(m_MultiLabelResultNode->GetData()); mitk::CastToItkImage(multiLabelSegmentation, itkImage); filter->SetInput(itkImage); filter->SetLowerThreshold(regionID); filter->SetUpperThreshold(regionID); filter->SetInsideValue(1); filter->SetOutsideValue(0); filter->Update(); mitk::Image::Pointer binarySegmentation; mitk::CastToMitkImage( filter->GetOutput(), binarySegmentation); m_BinaryPreviewNode->SetData(binarySegmentation); m_BinaryPreviewNode->SetVisibility(true); m_BinaryPreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(false)); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); }
void mitk::TensorImage::ConstructRgbImage() { typedef itk::Image<itk::DiffusionTensor3D<float>,3> ImageType; typedef itk::TensorToRgbImageFilter<ImageType> FilterType; FilterType::Pointer filter = FilterType::New(); ImageType::Pointer itkvol = ImageType::New(); mitk::CastToItkImage<ImageType>(this, itkvol); filter->SetInput(itkvol); filter->Update(); m_RgbImage = mitk::Image::New(); m_RgbImage->InitializeByItk( filter->GetOutput() ); m_RgbImage->SetVolume( filter->GetOutput()->GetBufferPointer() ); }
void mitk::QBallImage::ConstructRgbImage() { typedef itk::Image<itk::Vector<float,QBALL_ODFSIZE>,3> ImageType; typedef itk::QBallToRgbImageFilter<ImageType> FilterType; FilterType::Pointer filter = FilterType::New(); ImageType::Pointer itkvol = ImageType::New(); mitk::CastToItkImage<ImageType>(this, itkvol); filter->SetInput(itkvol); filter->Update(); m_RgbImage = mitk::Image::New(); m_RgbImage->InitializeByItk( filter->GetOutput() ); m_RgbImage->SetVolume( filter->GetOutput()->GetBufferPointer() ); }
int main( int argc, char** argv ) { if( argc < 2 ) { std::cerr << "Usage: " << argv[0] << " inputImage" << std::endl; return 1; } const unsigned int Dimension = 3; typedef float PixelType; typedef itk::Image< PixelType, Dimension > ImageType; typedef itk::ImageFileReader< ImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( argv[1] ); try { reader->Update(); } catch( itk::ExceptionObject& e ) { std::cerr << "Error: " << e << std::endl; return 1; } ImageType::ConstPointer output = reader->GetOutput(); typedef itk::BoxMeanImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); FilterType::RadiusType radius; radius.Fill( 3 ); filter->SetRadius( radius ); try { filter->Update(); } catch( itk::ExceptionObject& e ) { std::cerr << "Error: " << e << std::endl; return 1; } return 0; }
void Preprocess::CannyEdgeDetection(float variance, float upperThreshold, float lowerThreshold) { typedef itk::CastImageFilter< ImageType3D, FloatImageType3D > CastFilterType; CastFilterType::Pointer cast = CastFilterType::New(); cast->SetInput( myImg ); typedef itk::CannyEdgeDetectionImageFilter< FloatImageType3D, FloatImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( cast->GetOutput() ); filter->SetUpperThreshold(upperThreshold); //Threshold for detected edges = threshold filter->SetLowerThreshold(lowerThreshold); //Threshold for detected edges = threshold/2 //filter->SetThreshold(threshold); //Lowest allowed value in the output image filter->SetVariance(variance); //For Gaussian smoothing //filter->SetMaximumError(.01f); //For Gaussian smoothing try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "Exception caught: " << err << std::endl; } myImg = RescaleFloatToImageType( filter->GetOutput() ); }
void QmitkPreprocessingView::DoAdcCalculation() { if (m_DiffusionImage.IsNull()) return; typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType; typedef itk::AdcImageFilter< DiffusionPixelType, double > FilterType; for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++) { DiffusionImageType::Pointer inImage = dynamic_cast< DiffusionImageType* >(m_SelectedDiffusionNodes.at(i)->GetData()); FilterType::Pointer filter = FilterType::New(); filter->SetInput(inImage->GetVectorImage()); filter->SetGradientDirections(inImage->GetDirections()); filter->SetB_value(inImage->GetReferenceBValue()); filter->Update(); mitk::Image::Pointer image = mitk::Image::New(); image->InitializeByItk( filter->GetOutput() ); image->SetVolume( filter->GetOutput()->GetBufferPointer() ); mitk::DataNode::Pointer imageNode = mitk::DataNode::New(); imageNode->SetData( image ); QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str(); imageNode->SetName((name+"_ADC").toStdString().c_str()); GetDefaultDataStorage()->Add(imageNode); } }
void QmitkPreprocessingView::DoLengthCorrection() { if (m_DiffusionImage.IsNull()) return; typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType; typedef itk::DwiGradientLengthCorrectionFilter FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value()); filter->SetReferenceBValue(m_DiffusionImage->GetReferenceBValue()); filter->SetReferenceGradientDirectionContainer(m_DiffusionImage->GetDirections()); filter->Update(); DiffusionImageType::Pointer image = DiffusionImageType::New(); image->SetVectorImage( m_DiffusionImage->GetVectorImage()); image->SetReferenceBValue( filter->GetNewBValue() ); image->SetDirections( filter->GetOutputGradientDirectionContainer()); image->InitializeFromVectorImage(); mitk::DataNode::Pointer imageNode = mitk::DataNode::New(); imageNode->SetData( image ); QString name = m_SelectedDiffusionNodes.front()->GetName().c_str(); imageNode->SetName((name+"_rounded").toStdString().c_str()); GetDefaultDataStorage()->Add(imageNode); }
void Preprocess::VotingHoleFilling(int radiusX, int radiusY, int radiusZ, int iterations) { int size3 = myImg->GetLargestPossibleRegion().GetSize()[2]; if(size3==1) radiusZ = 0; ImageType3D::SizeType radius; radius[0] = radiusX; radius[1] = radiusY; radius[2] = radiusZ; typedef itk::VotingBinaryIterativeHoleFillingImageFilter< ImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetRadius(radius); filter->SetMajorityThreshold(2); filter->SetMaximumNumberOfIterations(iterations); filter->SetInput(myImg); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl ; return; } myImg = filter->GetOutput(); }
void Preprocess::InvertIntensity(void) { typedef itk::InvertIntensityImageFilter< ImageType3D, ImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( myImg ); filter->InPlaceOn(); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl ; } myImg = filter->GetOutput(); }
void Preprocess::ClosingFilter( int radius ) { typedef itk::BinaryBallStructuringElement<PixelType,3> StructuringElementType; typedef itk::GrayscaleMorphologicalClosingImageFilter<ImageType3D, ImageType3D, StructuringElementType > FilterType; FilterType::Pointer close = FilterType::New(); StructuringElementType structuringElement; structuringElement.CreateStructuringElement(); structuringElement.SetRadius(radius); close->SetKernel( structuringElement ); close->SetInput(myImg); try { close->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "Exception caught: " << err << std::endl; } myImg = close->GetOutput(); }
int main( int argc, char * argv[] ) { if( argc < 7 ) { std::cerr << "Usage: " << std::endl; std::cerr << argv[0] << std::endl; std::cerr << " <InputImage> <OutputImage> <LowerThreshold>"; std::cerr << " <UpperThreshold> <OutsideValue> <InsideValue>" << std::endl; return EXIT_FAILURE; } const unsigned int Dimension = 2; typedef unsigned char PixelType; const char * InputImage = argv[1]; const char * OutputImage = argv[2]; const PixelType LowerThreshold = static_cast<PixelType>(atoi( argv[3] ) ); const PixelType UpperThreshold = static_cast<PixelType>(atoi( argv[4] ) ); const PixelType OutsideValue = static_cast<PixelType>(atoi( argv[5] ) ); const PixelType InsideValue = static_cast<PixelType>(atoi( argv[6] ) ); typedef itk::Image< PixelType, Dimension > ImageType; typedef itk::ImageFileReader< ImageType > ReaderType; ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( InputImage ); typedef itk::BinaryThresholdImageFilter< ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( reader->GetOutput() ); filter->SetLowerThreshold( LowerThreshold ); filter->SetUpperThreshold( UpperThreshold ); filter->SetOutsideValue( OutsideValue ); filter->SetInsideValue( InsideValue ); typedef itk::ImageFileWriter< ImageType > WriterType; WriterType::Pointer writer = WriterType::New(); writer->SetFileName( OutputImage ); writer->SetInput( filter->GetOutput() ); try { writer->Update(); } catch( itk::ExceptionObject & e ) { std::cerr << "Error: " << e << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }
void Preprocess::DiscreteGaussianFilter(float varX, float varY, float varZ, float maxError) { typedef itk::DiscreteGaussianImageFilter<ImageType3D, FloatImageType3D> FilterType; FilterType::Pointer filter = FilterType::New(); FilterType::ArrayType maxErr; maxErr.Fill(maxError); filter->SetMaximumError( maxErr ); FilterType::ArrayType variance; variance[0] = varX; variance[1] = varY; variance[2] = varZ; filter->SetVariance(variance); filter->SetInput( myImg ); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl ; return; } myImg = RescaleFloatToImageType( filter->GetOutput() ); }
void Preprocess::BinaryThinning() { typedef itk::BinaryThinningImageFilter3D< ImageType3D, ImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( myImg ); //Rescale Output: typedef itk::RescaleIntensityImageFilter< ImageType3D, ImageType3D > RescaleType; RescaleType::Pointer rescale = RescaleType::New(); rescale->SetOutputMaximum( 255 ); rescale->SetOutputMinimum( 0 ); rescale->SetInput( filter->GetOutput() ); try { rescale->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl; } myImg = rescale->GetOutput(); }
int main() { typedef itk::Image<unsigned short, 3> ImageType; typedef itk::ImageFileReader<ImageType> ReaderType; typedef itk::ImageToVTKImageFilter<ImageType> FilterType; ReaderType::Pointer reader = ReaderType::New(); FilterType::Pointer connector = FilterType::New(); reader->SetFileName("testdata/test.dicom"); connector->SetInput(reader->GetOutput()); vtkImageViewer *viewer = vtkImageViewer::New(); vtkRenderWindowInteractor *renderWindowInteractor = vtkRenderWindowInteractor::New(); viewer->SetupInteractor(renderWindowInteractor); viewer->SetInput(connector->GetOutput()); viewer->Render(); viewer->SetColorWindow(255); viewer->SetColorLevel(128); renderWindowInteractor->Start(); return 0; }
int main(int argc, char* argv[]) { typedef itk::Image<unsigned char, 3> MaskImageType; typedef itk::Image<float, 3> ImageType; typedef itk::STAPLEImageFilter<MaskImageType, ImageType> FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetForegroundValue(2); for (int i = 2; i < argc; ++i) { MITK_INFO << argv[i]; MaskImageType::Pointer itkImg = MaskImageType::New(); mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(argv[i]); mitk::CastToItkImage(img,itkImg); filter->SetInput(i-2, itkImg); } filter->Update(); auto out = filter->GetOutput(); mitk::Image::Pointer outImg = mitk::Image::New(); mitk::CastToMitkImage(out, outImg); mitk::IOUtil::Save(outImg, argv[1]); return EXIT_SUCCESS; }
int main(int argc, char**argv) { typedef itk::GradientAnisotropicDiffusionImageFilter<FloatImageType, FloatImageType> FilterType; if(!file_exists(argv[3])) { InputImageType::Pointer im = readImage<InputImageType>(argv[1]); typedef itk::CastImageFilter<InputImageType,FloatImageType> CastFilter; typedef itk::CastImageFilter<FloatImageType,InputImageType> ReverseCastFilter; FilterType::Pointer filter = FilterType::New(); CastFilter::Pointer cfilter = CastFilter::New(); cfilter->SetInput(im); filter->SetInput(cfilter->GetOutput()); int num_i; float time_step; float conductance; sscanf(argv[2],"%d,%f,%f",&num_i,&time_step,&conductance); printf("time_step %f num_i %d conductance %f\n",time_step,num_i,conductance); filter->SetTimeStep(time_step); filter->SetNumberOfIterations(num_i); filter->SetConductanceParameter(conductance); filter->Update(); FloatImageType::Pointer imf = filter->GetOutput(); typedef itk::ImageRegionIterator<FloatImageType> IRI; IRI imageIterator(imf,imf->GetLargestPossibleRegion()); for(imageIterator.GoToBegin();!imageIterator.IsAtEnd(); ++imageIterator) { float value = imageIterator.Get(); value = ((value < 0)?0:((value>255)?255:value)); imageIterator.Set(value); } ReverseCastFilter::Pointer rfilter = ReverseCastFilter::New(); rfilter->SetInput(filter->GetOutput()); rfilter->Update(); writeImage<InputImageType>(rfilter->GetOutput(),argv[3]); } return 0; }
void AnisotropicDiffusion::process() { const VolumeBase* inputVolume = inport_.getData(); Volume* outputVolume = 0; typedef float InputPixelType; typedef float OutputPixelType; typedef itk::Image< InputPixelType, 3 > InputImageType; typedef itk::Image< OutputPixelType, 3 > OutputImageType; typedef itk::GradientAnisotropicDiffusionImageFilter< InputImageType, OutputImageType > FilterType; FilterType::Pointer filter = FilterType::New(); InputImageType::Pointer p = voreenToITK<float>(inputVolume); filter->SetInput(p); filter->SetNumberOfIterations(steps_.get()); filter->SetTimeStep( timeStep_.get() ); filter->SetConductanceParameter( conductance_.get() ); observe(filter.GetPointer()); // Now run the filter try { filter->Update(); } catch (itk::ExceptionObject &e) { LERROR(e); } outputVolume = ITKToVoreenCopy<float>(filter->GetOutput()); outputVolume->setRealWorldMapping(inputVolume->getRealWorldMapping()); transferTransformation(inputVolume, outputVolume); // assign computed volume to outport if (outputVolume) outport_.setData(outputVolume); else outport_.setData(0); }
/// /// Small application for demonstrating the interaction between MITK, /// ITK and VTK (not necessarily useful). /// int main( int /*argc*/, char ** argv ) { // MITK: Read a .pic.gz file, e.g. Core/Code/Testing/Data/Pic3D.pic.gz from // disk mitk::PicFileReader::Pointer reader = mitk::PicFileReader::New(); const char * filename = argv[1]; try { reader->SetFileName(filename); reader->Update(); } catch(...) { fprintf( stderr, "Could not open file %s \n\n", filename ); return EXIT_FAILURE; } mitk::Image::Pointer mitkImage = reader->GetOutput(); // ITK: Image smoothing // Create ITK image, cast from MITK image typedef itk::Image< short , 3 > ImageType; ImageType::Pointer itkImage = ImageType::New(); mitk::CastToItkImage( mitkImage, itkImage ); typedef itk::DiscreteGaussianImageFilter<ImageType, ImageType > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( itkImage ); filter->SetVariance( 2 ); filter->SetMaximumKernelWidth( 5 ); filter->Update(); // run filter // reimport filtered image data mitk::CastToMitkImage( filter->GetOutput(), mitkImage ); // VTK: Show result in renderwindow vtkImageViewer *viewer=vtkImageViewer::New(); vtkRenderWindowInteractor* renderWindowInteractor =vtkRenderWindowInteractor ::New(); viewer->SetupInteractor(renderWindowInteractor); viewer->SetInputData(mitkImage->GetVtkImageData()); viewer->Render(); viewer->SetColorWindow(255); viewer->SetColorLevel(128); renderWindowInteractor->Start(); renderWindowInteractor->Delete(); viewer->Delete(); return EXIT_SUCCESS; }
//void Preprocess::MinErrorThresholding(float *alpha_B, float *alpha_A, float *P_I) void Preprocess::MinErrorThresholding(float *alpha_B, float *alpha_A, float *P_I, bool overwrite) { //Binarize typedef itk::MinErrorThresholdImageFilter< ImageType3D, ImageType3D > FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput( myImg ); filter->SetNumberOfHistogramBins(256); try { filter->Update(); } catch( itk::ExceptionObject & err ) { std::cerr << "ITK FILTER ERROR: " << err << std::endl; } *alpha_B = (float)filter->GetAlphaLeft(); *alpha_A = (float)filter->GetAlphaRight(); *P_I = (float)filter->GetPriorLeft(); if(overwrite) myImg = filter->GetOutput(); }
void segmentation::on_filterButton_clicked() { typedef float InputPixelType; typedef float OutputPixelType; typedef itk::Image< InputPixelType, 3 > InputImageType; typedef itk::Image< OutputPixelType, 3> OutputImageType; typedef itk::ImageFileReader< InputImageType > ReaderType; typedef itk::CurvatureAnisotropicDiffusionImageFilter< InputImageType, OutputImageType > FilterType; FilterType::Pointer filter = FilterType::New(); ReaderType::Pointer reader = ReaderType::New(); reader->SetFileName( inputFileName); filter->SetInput( reader->GetOutput() ); const unsigned int numberOfIterations = 3;//5 const double timeStep = 0.0625; //timeStep=0.125(for 2D), 0.0625(for 3D) const double conductance = 3;//3 filter->SetNumberOfIterations( numberOfIterations ); filter->SetTimeStep( timeStep ); filter->SetConductanceParameter( conductance ); filter->Update();//time-costing typedef unsigned short WritePixelType;//unsigned char typedef itk::Image< WritePixelType, 3 > WriteImageType; typedef itk::RescaleIntensityImageFilter< OutputImageType, WriteImageType > RescaleFilterType; RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum( 0 ); rescaler->SetOutputMaximum( 65535 );//255 for CNV, for PED typedef itk::ImageFileWriter< WriteImageType > WriterType; WriterType::Pointer writer = WriterType::New(); //文件前缀名 filePrefix = inputFileName;//char* to string filePrefix = filePrefix.substr(0, filePrefix.length() - 4); filePrefix = filePrefix + "_filter.mhd"; strcpy(outputFileName, filePrefix.c_str());//string to char* writer->SetFileName(outputFileName); rescaler->SetInput( filter->GetOutput() ); writer->SetInput( rescaler->GetOutput() ); writer->Update(); //将结果图返回主窗口显示 emit returnOutputFileName(outputFileName);//发出信号 }
mitk::pa::Volume::Pointer mitk::pa::VolumeManipulator::RescaleImage(Volume::Pointer image, double ratio, double sigma) { MITK_INFO << "Rescaling image.."; typedef itk::Image<double, 3> ImageType; typedef itk::ResampleImageFilter<ImageType, ImageType> FilterType; typedef itk::GaussianInterpolateImageFunction<ImageType, double> InterpolatorType; auto input = image->AsMitkImage(); ImageType::Pointer itkInput = ImageType::New(); mitk::CastToItkImage(input, itkInput); ImageType::SizeType outputSize; outputSize[0] = input->GetDimensions()[0] * ratio; outputSize[1] = input->GetDimensions()[1] * ratio; outputSize[2] = input->GetDimensions()[2] * ratio; FilterType::Pointer resampleImageFilter = FilterType::New(); resampleImageFilter->SetInput(itkInput); resampleImageFilter->SetSize(outputSize); if (sigma > mitk::eps) { auto interpolator = InterpolatorType::New(); interpolator->SetSigma(sigma); resampleImageFilter->SetInterpolator(interpolator); } resampleImageFilter->SetOutputSpacing(input->GetGeometry()->GetSpacing()[0] / ratio); MITK_INFO << "Update.."; resampleImageFilter->UpdateLargestPossibleRegion(); MITK_INFO << "Update..[Done]"; ImageType::Pointer output = resampleImageFilter->GetOutput(); mitk::Image::Pointer mitkOutput = mitk::Image::New(); GrabItkImageMemory(output, mitkOutput); MITK_INFO << "Rescaling image..[Done]"; return Volume::New(mitkOutput); }
void mitk::SurfaceStampImageFilter::SurfaceStampBinaryOutputProcessing(MeshType *mesh) { auto *inputImage = this->GetInput(); mitk::Image::Pointer outputImage = this->GetOutput(); typedef itk::Image<unsigned char, 3> BinaryImageType; BinaryImageType::Pointer itkInputImage; mitk::CastToItkImage(inputImage, itkInputImage); typedef itk::TriangleMeshToBinaryImageFilter<MeshType, BinaryImageType> FilterType; FilterType::Pointer filter = FilterType::New(); filter->SetInput(mesh); filter->SetInfoImage(itkInputImage); filter->SetInsideValue(1); filter->SetOutsideValue(0); filter->Update(); BinaryImageType::Pointer resultImage = filter->GetOutput(); resultImage->DisconnectPipeline(); mitk::CastToMitkImage(resultImage, outputImage); }