#include <itkImageFileReader.h>
#include <itkImageSeriesReader.h>
#include <itkImageToVTKImageFilter.h>
-#include <itkAnalyzeImageIO.h>
#include <itkFlexibleVectorCastImageFilter.h>
+#include "itkVectorImageToImageAdaptor.h"
#include <vtkTransform.h>
else
std::cerr << "Error, input pixel type : " << InputPixelType << " unknown !" << std::endl;
- if (CLITK_EXPERIMENTAL && mLastError.size()==0) {
+ if (mLastError.size()==0) {
//ReadNkiImageTransform();
ReadMatImageTransform();
}
template<class InputPixelType, unsigned int VImageDimension>
void vvImageReader::UpdateWithDimAndInputPixelType()
{
- itk::AnalyzeImageIO *analyzeImageIO = NULL;
-
if (mType == MERGEDWITHTIME) // In this case we can load the images
// one at the time to avoid excessive
// memory use
reader->SetFileName(*i);
try {
mImage->AddItkImage<InputImageType>(reader->GetOutput());
+ mImage->ComputeScalarRangeBase<InputPixelType, VImageDimension-1>(reader->GetOutput());
} catch ( itk::ExceptionObject & err ) {
std::cerr << "Error while reading " << mInputFilenames[0].c_str()
<< " " << err << std::endl;
mLastError = error.str();
return;
}
- analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
}
} else if (mType == SLICED) {
mImage=vvImage::New();
filter->SetExtractionRegion(extractedRegion);
filter->SetInput(reader->GetOutput());
filter->ReleaseDataFlagOn();
-#if ITK_VERSION_MAJOR == 4
filter->SetDirectionCollapseToSubmatrix();
-#endif
try {
mImage->AddItkImage<SlicedImageType>(filter->GetOutput());
+ mImage->ComputeScalarRangeBase<InputPixelType, VImageDimension-1>(filter->GetOutput());
} catch ( itk::ExceptionObject & err ) {
std::cerr << "Error while slicing " << mInputFilenames[0].c_str()
<< "(slice #" << mSlice << ") " << err << std::endl;
return;
}
- analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
+ } else if (mType == VECTORPIXELIMAGE) {
+ mImage=vvImage::New();
+ typedef itk::VectorImage< InputPixelType, VImageDimension-1 > InputImageType;
+ typedef itk::ImageFileReader<InputImageType> ReaderType;
+ typedef itk::Image<InputPixelType, VImageDimension> OutputImageType;
+ typename ReaderType::Pointer reader = ReaderType::New();
+ reader->SetFileName(mInputFilenames[0]);
+ reader->Update();
+ typename InputImageType::Pointer input= reader->GetOutput();
+
+ typedef itk::VectorImageToImageAdaptor<InputPixelType, VImageDimension-1> ImageAdaptorType;
+ typename ImageAdaptorType::Pointer adaptor = ImageAdaptorType::New();
+ typename OutputImageType::Pointer output = OutputImageType::New();
+
+ adaptor->SetExtractComponentIndex(0);
+ adaptor->SetImage(input);
+
+ //Create the output
+ typename OutputImageType::IndexType index;
+ index.Fill(0);
+ typename OutputImageType::SizeType size;
+ size.Fill(input->GetNumberOfComponentsPerPixel());
+ typename OutputImageType::SpacingType spacing;
+ spacing.Fill(1);
+ typename OutputImageType::PointType origin;
+ origin.Fill(0);
+ typename OutputImageType::DirectionType direction;
+ direction.SetIdentity();
+ for (unsigned int pixelDim=0; pixelDim<VImageDimension-1; ++pixelDim)
+ {
+ size[pixelDim]=adaptor->GetLargestPossibleRegion().GetSize(pixelDim);
+ spacing[pixelDim]=input->GetSpacing()[pixelDim];
+ origin[pixelDim]=input->GetOrigin()[pixelDim];
+ for (unsigned int pixelDim2=0; pixelDim2<VImageDimension-1; ++pixelDim2)
+ {
+ direction[pixelDim][pixelDim2]=input->GetDirection()[pixelDim][pixelDim2];
+ }
+ }
+ typename OutputImageType::RegionType region;
+ region.SetSize(size);
+ region.SetIndex(index);
+ output->SetRegions(region);
+ output->SetOrigin(origin);
+ output->SetSpacing(spacing);
+ output->SetDirection(direction);
+ output->Allocate();
+
+ //Copy each channel
+ for (unsigned int pixelDim=0; pixelDim<input->GetNumberOfComponentsPerPixel(); ++pixelDim)
+ {
+ adaptor->SetExtractComponentIndex(pixelDim);
+
+ itk::ImageRegionIterator<InputImageType> imageIterator(input,input->GetLargestPossibleRegion());
+
+ while(!imageIterator.IsAtEnd())
+ {
+ typename OutputImageType::IndexType indexVector;
+ indexVector.Fill(0);
+ for (unsigned int indexDim=0; indexDim<VImageDimension-1; ++indexDim)
+ {
+ indexVector[indexDim]=imageIterator.GetIndex().GetElement(indexDim);
+ }
+ indexVector[VImageDimension-1]=pixelDim;
+
+ output->SetPixel(indexVector, adaptor->GetPixel(imageIterator.GetIndex()));
+ ++imageIterator;
+ }
+ }
+
+/* if (VImageDimension == 4)
+ mType == VECTORPIXELIMAGEWITHTIME;
+ else
+ mType == VECTORPIXELIMAGE;*/
+
+ try {
+ mImage = vvImageFromITK<VImageDimension,InputPixelType>(output, mType == VECTORPIXELIMAGEWITHTIME);
+ mImage->ComputeScalarRangeBase<InputPixelType, VImageDimension>(output);
+ } catch ( itk::ExceptionObject & err ) {
+ std::cerr << "Error while slicing " << mInputFilenames[0].c_str()
+ << " " << err << std::endl;
+ return;
+ }
} else {
if (mInputFilenames.size() > 1) {
typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
mLastError = error.str();
return;
}
- analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
}
}
- // For unknown analyze orientations, we set identity
- if(analyzeImageIO) {
- const double m[16] = {1.,0.,0.,0.,
- 0.,0.,1.,0.,
- 0.,-1.,0.,0.,
- 0.,0.,0.,1.};
- // TODO SR and BP: check on the list of transforms and not the first only
- int i;
- for(i=0; i<16 && m[i]==mImage->GetTransform()[0]->GetMatrix()->GetElement(i%4, i/4); i++);
- if(i==16) {
- itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
- << "Forcing identity orientation, use other file format if not ok.");
- mImage->GetTransform()[0]->Identity();
- }
- }
+ if (mType == DICOM && !mPatientCoordinateSystem)
+ mImage->InitializeTransform();
}
//----------------------------------------------------------------------------
template<class InputPixelType, unsigned int VImageDimension>
void vvImageReader::UpdateWithDimAndInputVectorPixelType()
{
- itk::AnalyzeImageIO *analyzeImageIO = NULL;
-
typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
typename InputImageType::Pointer input;
mLastError = error.str();
return;
}
- analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
}
typedef itk::Image< itk::Vector<float , 3>, VImageDimension > VectorImageType;
casted_input = caster->GetOutput();
mImage = vvImageFromITK<VImageDimension, itk::Vector<float, 3> >(casted_input, mType == IMAGEWITHTIME || mType == VECTORFIELDWITHTIME);
-
- // For unknown analyze orientations, we set identity
- if (analyzeImageIO)
- {
- const double m[16] = {1.,0.,0.,0.,
- 0.,0.,1.,0.,
- 0.,-1.,0.,0.,
- 0.,0.,0.,1.};
- int i;
- for (i = 0; i < 16 && m[i] == mImage->GetTransform()[0]->GetMatrix()->GetElement(i % 4, i / 4); i++)
- ;
- if (i == 16)
- {
- itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
- << "Forcing identity orientation, use other file format if not ok.");
- mImage->GetTransform()[0]->Identity();
- }
- }
}
//----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff