]> Creatis software - clitk.git/blob - common/vvImageReader.txx
obsolete since the user manually update his repo
[clitk.git] / common / vvImageReader.txx
1 /*=========================================================================
2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
3
4   Authors belong to:
5   - University of LYON              http://www.universite-lyon.fr/
6   - Léon Bérard cancer center       http://www.centreleonberard.fr
7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
8
9   This software is distributed WITHOUT ANY WARRANTY; without even
10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
11   PURPOSE.  See the copyright notices for more information.
12
13   It is distributed under dual licence
14
15   - BSD        See included LICENSE.txt file
16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
17   ===========================================================================**/
18
19 #ifndef VVIMAGEREADER_TXX
20 #define VVIMAGEREADER_TXX
21
22 #include <string>
23 #include <itkImageFileReader.h>
24 #include <itkImageSeriesReader.h>
25 #include <itkImageToVTKImageFilter.h>
26 #include <itkAnalyzeImageIO.h>
27
28 #include <vtkTransform.h>
29
30 #include "clitkCommon.h"
31 #include "clitkConfiguration.h"
32 #include "vvFromITK.h"
33 //----------------------------------------------------------------------------
34 template<unsigned int VImageDimension>
35 void vvImageReader::UpdateWithDim(std::string InputPixelType)
36 {
37   if (mType == VECTORFIELD || mType == VECTORFIELDWITHTIME)
38     UpdateWithDimAndInputPixelType<itk::Vector<float,3>,VImageDimension>();
39   else if (InputPixelType == "short")
40     UpdateWithDimAndInputPixelType<short,VImageDimension>();
41   else if (InputPixelType == "unsigned_short")
42     UpdateWithDimAndInputPixelType<unsigned short,VImageDimension>();
43   else if (InputPixelType == "char")
44     UpdateWithDimAndInputPixelType<char,VImageDimension>();
45   else if (InputPixelType == "unsigned_char")
46     UpdateWithDimAndInputPixelType<unsigned char,VImageDimension>();
47   else if (InputPixelType == "int")
48     UpdateWithDimAndInputPixelType<int,VImageDimension>();
49   else if (InputPixelType == "unsigned_int")
50     UpdateWithDimAndInputPixelType<unsigned int,VImageDimension>();
51   else if (InputPixelType == "double")
52     UpdateWithDimAndInputPixelType<double,VImageDimension>();
53   else if (InputPixelType == "float")
54     UpdateWithDimAndInputPixelType<float,VImageDimension>();
55   else
56     std::cerr << "Error, input pixel type : " << InputPixelType << " unknown !" << std::endl;
57
58   if (CLITK_EXPERIMENTAL && mLastError.size()==0) {
59     //ReadNkiImageTransform();
60     ReadMatImageTransform();
61   }
62 }
63 //----------------------------------------------------------------------------
64
65
66 //----------------------------------------------------------------------------
67 template<class InputPixelType, unsigned int VImageDimension>
68 void vvImageReader::UpdateWithDimAndInputPixelType()
69 {
70   itk::AnalyzeImageIO *analyzeImageIO = NULL;
71
72   if (mType == MERGEDWITHTIME)   // In this case we can load the images
73     // one at the time to avoid excessive
74     // memory use
75   {
76     mImage=vvImage::New();
77
78     for (std::vector<std::string>::const_iterator i=mInputFilenames.begin(); i!=mInputFilenames.end(); i++) {
79       typedef itk::Image< InputPixelType, VImageDimension-1 > InputImageType;
80       typedef itk::ImageFileReader<InputImageType> ReaderType;
81       typename ReaderType::Pointer reader = ReaderType::New();
82       reader->ReleaseDataFlagOn();
83       reader->SetFileName(*i);
84       try {
85         mImage->AddItkImage<InputImageType>(reader->GetOutput());
86       } catch ( itk::ExceptionObject & err ) {
87         std::cerr << "Error while reading " << mInputFilenames[0].c_str()
88                   << " " << err << std::endl;
89         std::stringstream error;
90         error << err;
91         mLastError = error.str();
92         return;
93       }
94       analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
95     }
96   } else if (mType == SLICED) {
97     mImage=vvImage::New();
98     typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
99     typedef itk::ImageFileReader<InputImageType> ReaderType;
100     typename ReaderType::Pointer reader = ReaderType::New();
101     reader->SetFileName(mInputFilenames[0]);
102     reader->UpdateOutputInformation();
103
104     typedef itk::Image< InputPixelType, VImageDimension-1 > SlicedImageType;
105     typedef itk::ExtractImageFilter<InputImageType, SlicedImageType> FilterType;
106
107     typename InputImageType::RegionType inputRegion = reader->GetOutput()->GetLargestPossibleRegion();
108     typename InputImageType::SizeType inputSize = inputRegion.GetSize();
109     typename InputImageType::IndexType start = inputRegion.GetIndex();
110     typename InputImageType::SizeType extractedRegionSize = inputSize;
111     typename InputImageType::RegionType extractedRegion;
112     extractedRegionSize[VImageDimension - 1] = 0;
113     extractedRegion.SetSize(extractedRegionSize);
114     start[VImageDimension - 1] = mSlice;
115     extractedRegion.SetIndex(start);
116
117     typename FilterType::Pointer filter = FilterType::New();
118     filter->SetExtractionRegion(extractedRegion);
119     filter->SetInput(reader->GetOutput());
120     filter->ReleaseDataFlagOn();
121 #if ITK_VERSION_MAJOR == 4
122     filter->SetDirectionCollapseToSubmatrix();
123 #endif
124     try {
125       mImage->AddItkImage<SlicedImageType>(filter->GetOutput());
126     } catch ( itk::ExceptionObject & err ) {
127       std::cerr << "Error while slicing " << mInputFilenames[0].c_str()
128                 << "(slice #" << mSlice << ") " << err << std::endl;
129       return;
130     }
131     analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
132   } else {
133     if (mInputFilenames.size() > 1) {
134       typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
135       typedef itk::ImageSeriesReader<InputImageType> ReaderType;
136       typename ReaderType::Pointer reader = ReaderType::New();
137       reader->SetFileNames(mInputFilenames);
138       reader->ReleaseDataFlagOn();
139
140       try {
141         if (mType == IMAGEWITHTIME)
142         {
143           std::cerr << "We should never come here:" << std::endl
144             << "  Calling vvImageReader with multiple images and IMAGEWITHTIME is undefined." << std::endl
145             << "  You are probably looking for MERGEDWITHTIME Type." << std::endl;
146           return;
147         }
148         else
149           mImage=vvImageFromITK<VImageDimension,InputPixelType>(reader->GetOutput());
150       } catch ( itk::ExceptionObject & err ) {
151         std::cerr << "Error while reading image series:" << err << std::endl;
152         std::stringstream error;
153         error << err;
154         mLastError = error.str();
155         return;
156       }
157     } else {
158       typedef itk::Image< InputPixelType, VImageDimension > InputImageType;
159       typedef itk::ImageFileReader<InputImageType> ReaderType;
160       typename ReaderType::Pointer reader = ReaderType::New();
161       reader->SetFileName(mInputFilenames[0]);
162       reader->ReleaseDataFlagOn();
163
164       try {
165         if (mType == IMAGEWITHTIME || mType == VECTORFIELDWITHTIME)
166           mImage=vvImageFromITK<VImageDimension,InputPixelType>(reader->GetOutput(),true);
167         else
168           mImage=vvImageFromITK<VImageDimension,InputPixelType>(reader->GetOutput());
169       } catch ( itk::ExceptionObject & err ) {
170         std::cerr << "Error while reading " << mInputFilenames[0].c_str()
171                   << " " << err << std::endl;
172         std::stringstream error;
173         error << err;
174         mLastError = error.str();
175         return;
176       }
177       analyzeImageIO = dynamic_cast<itk::AnalyzeImageIO*>( reader->GetImageIO() );
178     }
179   }
180
181   // For unknown analyze orientations, we set identity
182   if(analyzeImageIO) {
183     const double m[16] = {1.,0.,0.,0.,
184                           0.,0.,1.,0.,
185                           0.,-1.,0.,0.,
186                           0.,0.,0.,1.};
187     int i;
188     for(i=0; i<16 && m[i]==mImage->GetTransform()->GetMatrix()->GetElement(i%4, i/4); i++);
189     if(i==16) {
190       itkWarningMacro(<< "Analyze image file format detected with unknown orientation. "
191                       << "Forcing identity orientation, use other file format if not ok.");
192       mImage->GetTransform()->Identity();
193     }
194   }
195 }
196 //----------------------------------------------------------------------------
197
198
199 #endif /* end #define vvImageReader_TXX */
200