コード例 #1
0
ファイル: Isophotes.cpp プロジェクト: daviddoria/TempRepo
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);
}
コード例 #2
0
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;
}
コード例 #3
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
}
コード例 #4
0
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;
}
コード例 #5
0
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);
    }
}
コード例 #6
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
}
コード例 #7
0
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);
    }
}
コード例 #8
0
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);
  }
}
コード例 #9
0
ファイル: mitkOtsuTool3D.cpp プロジェクト: SaschaD-DKFZ/MITK
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();
}
コード例 #10
0
ファイル: mitkTensorImage.cpp プロジェクト: GHfangxin/MITK
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() );
}
コード例 #11
0
ファイル: mitkQBallImage.cpp プロジェクト: GHfangxin/MITK
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() );
}
コード例 #12
0
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;
}
コード例 #13
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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() );
}
コード例 #14
0
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);
  }
}
コード例 #15
0
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);
}
コード例 #16
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
}
コード例 #17
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
	
}
コード例 #18
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
}
コード例 #19
0
ファイル: treshhold.cpp プロジェクト: ihsanarifr/TugasKuliah
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;
}
コード例 #20
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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() );
   
}
コード例 #21
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
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();
}
コード例 #22
0
ファイル: main.cpp プロジェクト: Slin/Bloodnado
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;
}
コード例 #23
0
ファイル: CLStaple.cpp プロジェクト: Cdebus/MITK
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;
}
コード例 #24
0
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;
}
コード例 #25
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);
}
コード例 #26
0
ファイル: mitkWithITKAndVTK.cpp プロジェクト: ClydeChen/MITK
///
/// 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;
}
コード例 #27
0
ファイル: ftkPreprocess2.cpp プロジェクト: Pandolph/farsight
//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();
}
コード例 #28
0
ファイル: segmentation.cpp プロジェクト: zlsunsuda/QT-DEMO
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);//发出信号
}
コード例 #29
0
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);
}
コード例 #30
0
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);
}