Exemple #1
0
/*
set input image
- also compute the interpolators
*/
void
Tracer::SetInputData(ImagePointer image)
{
  data = ImageSOType::New();
  data->SetImage(image);

  // set the stepSize
  ImageType::SpacingType spacing
    = image->GetSpacing();
  stepSize = std::min( spacing[0], spacing[1] ) * 2;

  // set interpolators
  typedef itk::DerivativeImageFilter<ImageType,ImageType> FilterType;
  FilterType::Pointer filter[Dimension];

  for(unsigned int ui=0; 
      ui < Dimension; ++ui)
    {
      filter[ui] = FilterType::New();
      filter[ui]->SetDirection(ui);
      filter[ui]->SetInput( data->GetImage() );
      filter[ui]->Update();

      derivativeInterpolator[ui] = InterpolatorType::New();
      derivativeInterpolator[ui]->SetInputImage( filter[ui]->GetOutput() );
    } // next ui

  imageInterpolator = InterpolatorType::New();
  imageInterpolator->SetInputImage( data->GetImage() );
}
Exemple #2
0
void CAxialFor3DView::cropImage(ImagePointer source , ImagePointer target,int nStartSlice, int nEndSlice)
{
	const unsigned int Dimension = 3;

	typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType;
	typedef itk::ImageRegionIterator< ImageType>       IteratorType;

	ImageType::RegionType inputRegion;

	ImageType::RegionType::IndexType inputStart;
	ImageType::RegionType::SizeType  size;

	inputStart[0] = 0;//174 m_nCropStart[0]
	inputStart[1] = 0;//160 m_nCropStart[1]
	inputStart[2] = nStartSlice;

	size[0]  = m_nWidth;//193 m_nCropSize[0]
	size[1]  = m_nHeight;//193 m_nCropSize[1]
	size[2]  = nEndSlice-nStartSlice+1;//350 746

	inputRegion.SetSize( size );
	inputRegion.SetIndex( inputStart );

	ImageType::RegionType outputRegion;

	ImageType::RegionType::IndexType outputStart;

	outputStart[0] = 0;
	outputStart[1] = 0;
	outputStart[2] = 0;

	outputRegion.SetSize( size );
	outputRegion.SetIndex( outputStart );
	
	target->SetRegions( outputRegion );
	const ImageType::SpacingType& spacing = source->GetSpacing();
	const ImageType::PointType& inputOrigin = source->GetOrigin();
	double   outputOrigin[ Dimension ];

	for(unsigned int i=0; i< Dimension; i++)
	{
		outputOrigin[i] = inputOrigin[i] + spacing[i] * inputStart[i];
	}

	target->SetSpacing( spacing );
	target->SetOrigin(  outputOrigin );
	target->Allocate();

	ConstIteratorType inputIt(   source, inputRegion  );
	IteratorType      outputIt(  target, outputRegion );

	for ( inputIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd();
		++inputIt, ++outputIt)
	{
		outputIt.Set(  inputIt.Get()  );
	}	

	itkVTKResampleExporter->SetInput(target);
	VTKResampleImporter->SetDataOrigin(0,0,0);
	itkVTKResampleExporter->Update();

	greyPadder->SetInput(VTKResampleImporter->GetOutput());

	greyPadder->SetOutputWholeExtent(0,m_nWidth,0,m_nHeight,0,0);
	greyPadder->SetConstant(0);
	m_nSliceSum=nEndSlice-nStartSlice;

	m_bCropImage=true;
	VTKImporter->Delete();
	source->ReleaseData();
	//seriesReader->Delete();
	//itkVTKExporter->RemoveInput();
	//itkVTKExporter->RemoveOutput();
}