#include <itkCenteredEuler3DTransform.h>
#include <itkRecursiveGaussianImageFilter.h>
#include "clitkElastix.h"
+#include "clitkResampleImageWithOptionsFilter.h"
namespace clitk
{
// if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and signed_char..." << std::endl;
// UpdateWithDimAndPixelType<Dimension, signed char>();
// }
+ else if(PixelType == "double"){
+ if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and double..." << std::endl;
+ UpdateWithDimAndPixelType<Dimension, double>();
+ }
else {
if (m_Verbose) std::cout << "Launching filter in "<< Dimension <<"D and float..." << std::endl;
UpdateWithDimAndPixelType<Dimension, float>();
}
//-------------------------------------------------------------------
+
+
+ //-------------------------------------------------------------------
+ // Compute updated bounding box
+ //-------------------------------------------------------------------
+ template<class args_info_type>
+ vnl_vector<double>
+ AffineTransformGenericFilter<args_info_type>::ComputeSize(vnl_vector<double> inputSize, vnl_matrix<double> transformationMatrix, bool returnMin)
+ {
+ //Compute input corners
+ int Dimension = inputSize.size();
+ vnl_matrix<double> vnlOutputSize(std::pow(2, Dimension), Dimension);
+ vnlOutputSize.fill(0);
+ if (Dimension == 2) {
+ for(unsigned int i=0; i< Dimension; i++)
+ vnlOutputSize[3][i] = inputSize[i];
+ vnlOutputSize[1][0] = inputSize[0];
+ vnlOutputSize[2][1] = inputSize[1];
+ } else if (Dimension == 3) {
+ for(unsigned int i=0; i< Dimension; i++)
+ vnlOutputSize[7][i] = inputSize[i];
+ vnlOutputSize[1][0] = inputSize[0];
+ vnlOutputSize[2][1] = inputSize[1];
+ vnlOutputSize[3][2] = inputSize[2];
+ vnlOutputSize[4][0] = inputSize[0];
+ vnlOutputSize[4][1] = inputSize[1];
+ vnlOutputSize[5][1] = inputSize[1];
+ vnlOutputSize[5][2] = inputSize[2];
+ vnlOutputSize[6][0] = inputSize[0];
+ vnlOutputSize[6][2] = inputSize[2];
+ } else { //Dimension ==4
+ for(unsigned int i=0; i< Dimension; i++)
+ vnlOutputSize[15][i] = inputSize[i];
+ vnlOutputSize[1][0] = inputSize[0];
+ vnlOutputSize[2][1] = inputSize[1];
+ vnlOutputSize[3][2] = inputSize[2];
+ vnlOutputSize[4][3] = inputSize[3];
+ vnlOutputSize[5][0] = inputSize[0];
+ vnlOutputSize[5][1] = inputSize[1];
+ vnlOutputSize[6][0] = inputSize[0];
+ vnlOutputSize[6][2] = inputSize[2];
+ vnlOutputSize[7][0] = inputSize[0];
+ vnlOutputSize[7][3] = inputSize[3];
+ vnlOutputSize[8][1] = inputSize[1];
+ vnlOutputSize[8][2] = inputSize[2];
+ vnlOutputSize[9][1] = inputSize[1];
+ vnlOutputSize[9][3] = inputSize[3];
+ vnlOutputSize[10][2] = inputSize[2];
+ vnlOutputSize[10][3] = inputSize[3];
+ vnlOutputSize[11][0] = inputSize[0];
+ vnlOutputSize[11][1] = inputSize[1];
+ vnlOutputSize[11][2] = inputSize[2];
+ vnlOutputSize[12][0] = inputSize[0];
+ vnlOutputSize[12][1] = inputSize[1];
+ vnlOutputSize[12][3] = inputSize[3];
+ vnlOutputSize[13][0] = inputSize[0];
+ vnlOutputSize[13][2] = inputSize[2];
+ vnlOutputSize[13][3] = inputSize[3];
+ vnlOutputSize[14][1] = inputSize[1];
+ vnlOutputSize[14][2] = inputSize[2];
+ vnlOutputSize[14][3] = inputSize[3];
+ }
+
+ //Compute the transformation of all corner
+ for (unsigned int i=0; i< std::pow(2, Dimension); ++i)
+ vnlOutputSize.set_row(i, transformationMatrix*vnlOutputSize.get_row(i));
+
+ //Compute the bounding box taking the max and the min
+ vnl_vector<double> minBB(vnlOutputSize.get_row(0)), maxBB(vnlOutputSize.get_row(0));
+ for (unsigned int i=0; i< std::pow(2, Dimension); ++i) {
+ for (unsigned int j=0; j< Dimension; ++j) {
+ if (vnlOutputSize[i][j] < minBB[j])
+ minBB[j] = vnlOutputSize[i][j];
+ if (vnlOutputSize[i][j] > maxBB[j])
+ maxBB[j] = vnlOutputSize[i][j];
+ }
+ }
+
+ //Compute the size
+ if (returnMin)
+ return minBB;
+ else {
+ vnl_vector<double> size;
+ size = maxBB - minBB;
+
+ return size;
+ }
+ }
+ //-------------------------------------------------------------------
//-------------------------------------------------------------------
reader->Update();
typename InputImageType::Pointer input= reader->GetOutput();
+ //Adaptative size, spacing origin (use previous clitkResampleImage)
+ if (m_ArgsInfo.adaptive_given) {
+ // Filter
+ typedef clitk::ResampleImageWithOptionsFilter<InputImageType, OutputImageType> ResampleImageFilterType;
+ typename ResampleImageFilterType::Pointer filter = ResampleImageFilterType::New();
+ filter->SetInput(input);
+
+ // Set Verbose
+ filter->SetVerboseOptions(m_ArgsInfo.verbose_flag);
+
+ // Set size / spacing
+ static const unsigned int dim = OutputImageType::ImageDimension;
+ typename OutputImageType::SpacingType spacing;
+ typename OutputImageType::SizeType size;
+ typename OutputImageType::PointType origin;
+ typename OutputImageType::DirectionType direction;
+
+ if (m_ArgsInfo.like_given) {
+ itk::ImageIOBase::Pointer header = clitk::readImageHeader(m_ArgsInfo.like_arg);
+ if (header) {
+ for(unsigned int i=0; i<dim; i++){
+ spacing[i] = header->GetSpacing(i);
+ size[i] = header->GetDimensions(i);
+ origin[i] = header->GetOrigin(i);
+ }
+ for(unsigned int i=0; i<dim; i++) {
+ for(unsigned int j=0;j<dim;j++) {
+ direction(i,j) = header->GetDirection(i)[j];
+ }
+ }
+ filter->SetOutputSpacing(spacing);
+ filter->SetOutputSize(size);
+ filter->SetOutputOrigin(origin);
+ filter->SetOutputDirection(direction);
+ }
+ else {
+ std::cerr << "*** Warning : I could not read '" << m_ArgsInfo.like_arg << "' ***" << std::endl;
+ exit(0);
+ }
+ }
+ else {
+ if (m_ArgsInfo.spacing_given == 1) {
+ filter->SetOutputIsoSpacing(m_ArgsInfo.spacing_arg[0]);
+ }
+ else if ((m_ArgsInfo.spacing_given != 0) && (m_ArgsInfo.size_given != 0)) {
+ std::cerr << "Error: use spacing or size, not both." << std::endl;
+ exit(0);
+ }
+ else if (m_ArgsInfo.spacing_given) {
+ if ((m_ArgsInfo.spacing_given != 0) && (m_ArgsInfo.spacing_given != dim)) {
+ std::cerr << "Error: spacing should have one or " << dim << " values." << std::endl;
+ exit(0);
+ }
+ for(unsigned int i=0; i<dim; i++)
+ spacing[i] = m_ArgsInfo.spacing_arg[i];
+ filter->SetOutputSpacing(spacing);
+ }
+ else if (m_ArgsInfo.size_given) {
+ if ((m_ArgsInfo.size_given != 0) && (m_ArgsInfo.size_given != dim)) {
+ std::cerr << "Error: size should have " << dim << " values." << std::endl;
+ exit(0);
+ }
+ for(unsigned int i=0; i<dim; i++)
+ size[i] = m_ArgsInfo.size_arg[i];
+ filter->SetOutputSize(size);
+ }
+ for(unsigned int i=0; i<dim; i++){
+ origin[i] = input->GetOrigin()[i];
+ }
+ for(unsigned int i=0; i<dim; i++) {
+ for(unsigned int j=0;j<dim;j++) {
+ direction(i,j) = input->GetDirection()[i][j];
+ }
+ }
+ filter->SetOutputOrigin(origin);
+ filter->SetOutputDirection(direction);
+ }
+
+ // Set temporal dimension
+ //filter->SetLastDimensionIsTime(m_ArgsInfo.time_flag);
+
+ // Set Gauss
+ filter->SetGaussianFilteringEnabled(m_ArgsInfo.autogauss_flag);
+ if (m_ArgsInfo.gauss_given != 0) {
+ typename ResampleImageFilterType::GaussianSigmaType g;
+ for(unsigned int i=0; i<dim; i++) {
+ g[i] = m_ArgsInfo.gauss_arg[i];
+ }
+ filter->SetGaussianSigma(g);
+ }
+
+ // Set Interpolation
+ int interp = m_ArgsInfo.interp_arg;
+ if (interp == 0) {
+ filter->SetInterpolationType(ResampleImageFilterType::NearestNeighbor);
+ } else {
+ if (interp == 1) {
+ filter->SetInterpolationType(ResampleImageFilterType::Linear);
+ } else {
+ if (interp == 2) {
+ filter->SetInterpolationType(ResampleImageFilterType::BSpline);
+ } else {
+ if (interp == 3) {
+ filter->SetInterpolationType(ResampleImageFilterType::B_LUT);
+ } else {
+ std::cerr << "Error. I do not know interpolation '" << m_ArgsInfo.interp_arg
+ << "'. Choose among: nn, linear, bspline, blut, windowed sinc" << std::endl;
+ exit(0);
+ }
+ }
+ }
+ }
+
+ // Set default pixel value
+ filter->SetDefaultPixelValue(m_ArgsInfo.pad_arg);
+
+ // Set thread
+ //if (m_ArgsInfo.thread_given) {
+ // filter->SetNumberOfThreads(m_ArgsInfo.thread_arg);
+ //}
+
+ // Go !
+ filter->Update();
+ typename OutputImageType::Pointer output = filter->GetOutput();
+ //this->template SetNextOutput<OutputImageType>(outputImage);
+
+ // Output
+ typedef itk::ImageFileWriter<OutputImageType> WriterType;
+ typename WriterType::Pointer writer = WriterType::New();
+ writer->SetFileName(m_ArgsInfo.output_arg);
+ writer->SetInput(output);
+ writer->Update();
+
+ return;
+ }
+
//Gaussian pre-filtering
typename itk::Vector<double, Dimension> gaussianSigma;
gaussianSigma.Fill(0);
if (m_ArgsInfo.origin_given)
std::cout << "Warning --origin ignored (because --transform_grid_flag)" << std::endl;
- // Spacing is influenced by affine transform matrix and input direction
- typename InputImageType::SpacingType outputSpacing;
- outputSpacing = invRotMatrix *
- input->GetDirection() *
- input->GetSpacing();
- if (autoGaussEnabled) { // Automated sigma when downsample
- for(unsigned int i=0; i<Dimension; i++) {
- if (outputSpacing[i] > input->GetSpacing()[i]) { // downsample
- gaussianSigma[i] = 0.5*outputSpacing[i];// / inputSpacing[i]);
- }
- else gaussianSigma[i] = 0; // will be ignore after
- }
- }
-
// Origin is influenced by translation but not by input direction
typename InputImageType::PointType outputOrigin;
outputOrigin = invRotMatrix *
// Size is influenced by affine transform matrix and input direction
// Size is converted to double, transformed and converted back to size type.
- vnl_vector<double> vnlOutputSize(Dimension);
+ // Determine the bounding box tranforming all corners
+ vnl_vector<double> vnlOutputSize(Dimension), vnlOutputmmSize(Dimension), vnlOutputOffset(Dimension);
+ typename InputImageType::SpacingType outputSpacing;
for(unsigned int i=0; i< Dimension; i++) {
vnlOutputSize[i] = input->GetLargestPossibleRegion().GetSize()[i];
+ vnlOutputmmSize[i] = input->GetLargestPossibleRegion().GetSize()[i]*input->GetSpacing()[i];
+ vnlOutputOffset[i] = input->GetLargestPossibleRegion().GetSize()[i]*input->GetSpacing()[i];
+ }
+ vnlOutputSize = ComputeSize(vnlOutputSize, invRotMatrix.GetVnlMatrix() * input->GetDirection().GetVnlMatrix(), 0);
+ vnlOutputmmSize = ComputeSize(vnlOutputmmSize, invRotMatrix.GetVnlMatrix() * input->GetDirection().GetVnlMatrix(), 0);
+ vnlOutputOffset = ComputeSize(vnlOutputOffset, invRotMatrix.GetVnlMatrix() * input->GetDirection().GetVnlMatrix(), 1);
+ for(unsigned int i=0; i< Dimension; i++) {
+ outputSpacing[i] = vnlOutputmmSize[i]/lrint(vnlOutputSize[i]);
+ outputOrigin[i] += vnlOutputOffset[i];
}
- vnlOutputSize = invRotMatrix *
- input->GetDirection().GetVnlMatrix() *
- vnlOutputSize;
+ if (autoGaussEnabled) { // Automated sigma when downsample
+ for(unsigned int i=0; i<Dimension; i++) {
+ if (outputSpacing[i] > input->GetSpacing()[i]) { // downsample
+ gaussianSigma[i] = 0.5*outputSpacing[i];// / inputSpacing[i]);
+ }
+ else gaussianSigma[i] = 0; // will be ignore after
+ }
+ }
+
typename OutputImageType::SizeType outputSize;
for(unsigned int i=0; i< Dimension; i++) {
// If the size is negative, we have a flip and we must modify
}
//Filter
+#if ( ITK_VERSION_MAJOR < 5 )
typedef itk::VectorResampleImageFilter< InputImageType,OutputImageType, double > ResampleFilterType;
+#else
+ typedef itk::ResampleImageFilter< InputImageType,OutputImageType, double > ResampleFilterType;
+#endif
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
// Matrix
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff