]> Creatis software - clitk.git/blob - common/clitkImageCommon.txx
add cache for read image
[clitk.git] / common / clitkImageCommon.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://oncora1.lyon.fnclcc.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 #ifndef CLITKIMAGECOMMON_TXX
19 #define CLITKIMAGECOMMON_TXX
20
21
22 //--------------------------------------------------------------------
23 template<class PixelType>
24 typename itk::Image<PixelType,1>::Pointer 
25 NewImage1D(int vsize, double vspacing)
26 {
27   typedef itk::Image<PixelType,1> ImageType;
28   typename ImageType::Pointer g = ImageType::New();
29   typename ImageType::SizeType size;
30   size[0] = vsize;
31   typename ImageType::RegionType region;
32   region.SetSize(size);
33   g->SetRegions(region);
34   typename ImageType::SpacingType spacing;
35   spacing[0] = vspacing;
36   g->SetSpacing(spacing);
37   return g;
38 }
39 //--------------------------------------------------------------------
40
41 //--------------------------------------------------------------------
42 template<class PixelType>
43 typename itk::Image<PixelType,2>::Pointer 
44 NewImage2D(int sx, int sy, double dx, double dy)
45 {
46   typedef itk::Image<PixelType,2> ImageType;
47   typename ImageType::Pointer g = ImageType::New();
48   typename ImageType::SizeType size;
49   size[0] = sx;
50   size[1] = sy;
51   typename ImageType::RegionType region;
52   region.SetSize(size);
53   g->SetRegions(region);
54   typename ImageType::SpacingType spacing;
55   spacing[0] = dx;
56   spacing[1] = dy;
57   g->SetSpacing(spacing);
58   return g;
59 }
60 //--------------------------------------------------------------------
61
62
63 //--------------------------------------------------------------------
64 template<class PixelType>
65 typename itk::Image<PixelType,3>::Pointer 
66 NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz)
67 {
68   typedef itk::Image<PixelType,3> ImageType;
69   typename ImageType::Pointer g = ImageType::New();
70   typename ImageType::SizeType size;
71   size[0] = sx;
72   size[1] = sy;
73   size[2] = sz;
74   typename ImageType::RegionType region;
75   region.SetSize(size);
76   g->SetRegions(region);
77   typename ImageType::SpacingType spacing;
78   spacing[0] = dx;
79   spacing[1] = dy;
80   spacing[2] = dz;
81   g->SetSpacing(spacing);
82   return g;
83 }
84 //--------------------------------------------------------------------
85
86 //--------------------------------------------------------------------
87 template<class PixelType>
88 typename itk::Image<PixelType,4>::Pointer NewImage4D(int sx, int sy, int sz, int st, double dx, double dy, double dz, double dt)
89 {
90   typedef itk::Image<PixelType,3> ImageType;
91   typename ImageType::Pointer g = ImageType::New();
92   typename ImageType::SizeType size;
93   size[0] = sx;
94   size[1] = sy;
95   size[2] = sz;
96   size[3] = st;
97   typename ImageType::RegionType region;
98   region.SetSize(size);
99   g->SetRegions(region);
100   typename ImageType::SpacingType spacing;
101   spacing[0] = dx;
102   spacing[1] = dy;
103   spacing[2] = dz;
104   spacing[3] = dt;
105   g->SetSpacing(spacing);
106   return g;
107 }
108 //--------------------------------------------------------------------
109
110
111 //--------------------------------------------------------------------
112 template<class ImageType>
113 typename ImageType::Pointer NewImageLike(const typename ImageType::Pointer input, bool allocate)
114 {
115   typename ImageType::Pointer output = ImageType::New();
116   output->CopyInformation(input);
117   output->SetRegions(input->GetLargestPossibleRegion());
118   if (allocate) output->Allocate();
119   return output;
120 }
121 //--------------------------------------------------------------------
122
123
124 //--------------------------------------------------------------------
125 template<class ImageType>
126 void CopyValues(const typename ImageType::Pointer input,
127                 typename ImageType::Pointer output)
128 {
129   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
130   ConstIteratorType pi(input,input->GetLargestPossibleRegion());
131   pi.GoToBegin();
132   typedef itk::ImageRegionIterator<ImageType> IteratorType;
133   IteratorType po(output,input->GetLargestPossibleRegion());
134   po.GoToBegin();
135   while (!pi.IsAtEnd()) {
136     po.Set(pi.Get());
137     ++pi;
138     ++po;
139   }
140 }
141 //--------------------------------------------------------------------
142
143
144 //--------------------------------------------------------------------
145 template<class ImageType>
146 typename ImageType::Pointer readImage(const std::string & filename, const bool verbose)
147 {
148   typedef itk::ImageFileReader<ImageType> ReaderType;
149   typename ReaderType::Pointer reader = ReaderType::New();
150   reader->SetFileName(filename.c_str());
151   if (verbose) {
152     std::cout << "Reading [" << filename << "] ... " << std::endl;
153   }
154   try {
155     reader->Update();
156   } catch(itk::ExceptionObject & err) {
157     std::cerr << "Exception while reading image [" << filename << "]" << std::endl;
158     std::cerr << err << std::endl;
159     exit(0);
160   }
161   return reader->GetOutput();
162 }
163 //--------------------------------------------------------------------
164
165 //--------------------------------------------------------------------
166 template<typename ImageType>
167 typename ImageType::Pointer readImage(const std::vector<std::string> & filenames,
168                                       const bool verbose)
169 {
170   if (filenames.size() == 1) return readImage<ImageType>(filenames[0], verbose);
171   typedef itk::ImageSeriesReader<ImageType> ReaderType;
172   typename ReaderType::Pointer reader = ReaderType::New();
173   reader->SetFileNames(filenames);
174   if (verbose) {
175     std::cout << "Reading " << filenames[0] << " and others ..." << std::endl;
176   }
177   try {
178     reader->Update();
179   } catch( itk::ExceptionObject & err ) {
180     std::cerr << "Error while reading " << filenames[0]
181               << " or other files ..." << err << std::endl;
182     exit(0);
183   }
184   return reader->GetOutput();
185 }
186 //--------------------------------------------------------------------
187
188
189 //--------------------------------------------------------------------
190 template<class ImageType>
191 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose)
192 {
193   typedef itk::ImageFileWriter<ImageType> WriterType;
194   typename WriterType::Pointer writer = WriterType::New();
195   writer->SetFileName(filename.c_str());
196   writer->SetInput(image);
197   if (verbose) {
198     std::cout << "Writing [" << filename << "] ... " << std::endl;
199   }
200   try {
201     writer->Update();
202   } catch( itk::ExceptionObject & err ) {
203     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
204     std::cerr << err << std::endl;
205     exit(-1);
206   }
207 }
208 //--------------------------------------------------------------------
209
210
211 //--------------------------------------------------------------------
212 template<class ImageType>
213 void writeImage(const ImageType* image, const std::string & filename, const bool verbose)
214 {
215   typedef itk::ImageFileWriter<ImageType> WriterType;
216   typename WriterType::Pointer writer = WriterType::New();
217   writer->SetFileName(filename.c_str());
218   writer->SetInput(image);
219   if (verbose) {
220     std::cout << "Writing [" << filename << "] ... " << std::endl;
221   }
222   try {
223     writer->Update();
224   } catch( itk::ExceptionObject & err ) {
225     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
226     std::cerr << err << std::endl;
227     exit(-1);
228   }
229 }
230 // //--------------------------------------------------------------------
231
232 // //--------------------------------------------------------------------
233 // template<class ImageType>
234 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
235 //   typedef itk::ImageFileWriter<ImageType> WriterType;
236 //   typename WriterType::Pointer writer = WriterType::New();
237 //   writer->SetFileName(filename.c_str());
238 //   writer->SetInput(image);
239 //   if (verbose) {
240 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
241 //   }
242 //   try {
243 //     writer->Update();
244 //   }
245 //   catch( itk::ExceptionObject & err ) {
246 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
247 //     std::cerr << err << std::endl;
248 //     exit(-1);
249 //   }
250 // }
251
252 //--------------------------------------------------------------------
253
254 //--------------------------------------------------------------------
255 // Compute the number of different intensities in an image
256 template<class ImageType>
257 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
258                                      std::vector<typename ImageType::PixelType> & l)
259 {
260   //std::set<typename ImageType::PixelType> listOfIntensities;
261   std::map<typename ImageType::PixelType, bool> listOfIntensities;
262   //  listOfIntensities.resize(0);
263   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
264   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
265   pi.Begin();
266   while (!pi.IsAtEnd()) {
267     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
268     // if (std::find(listOfIntensities.begin(),
269     //                            listOfIntensities.end(),
270     //                            pi.Get()) == listOfIntensities.end()) {
271     //    listOfIntensities.insert(pi.Get());
272     //  }
273     ++pi;
274   }
275
276   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
277   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
278   while (ppi != listOfIntensities.end()) {
279     l.push_back(ppi->first);
280     ++ppi;
281   }
282
283   return listOfIntensities.size();
284 }
285 //--------------------------------------------------------------------
286
287
288 //--------------------------------------------------------------------
289 template<class InputImageType, class MaskImageType>
290 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
291                                  const typename MaskImageType::Pointer & mask,
292                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
293                                  std::map<typename MaskImageType::PixelType,
294                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
295 {
296   // Check size
297   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
298     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
299                              << std::endl
300                              << "Input = " << input->GetLargestPossibleRegion()
301                              << std::endl
302                              << "Mask = " << mask->GetLargestPossibleRegion());
303   }
304
305   // reset weights list
306   mapOfLabelsAndWeights.clear();
307
308   // loop
309   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
310   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
311   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
312   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
313   pi.Begin();
314   pm.Begin();
315   while (!pi.IsAtEnd()) {
316     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
317     ++pi;
318     ++pm;
319   }
320 }
321 //--------------------------------------------------------------------
322
323
324 //--------------------------------------------------------------------
325 template<class ImageType1, class ImageType2>
326 bool HaveSameSizeAndSpacing(typename ImageType1::ConstPointer A, 
327                            typename ImageType2::ConstPointer B) 
328 {
329   if (A->GetImageDimension() != B->GetImageDimension()) return false;
330   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
331     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
332     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
333   }
334   return true;
335 }
336 //--------------------------------------------------------------------
337
338 //--------------------------------------------------------------------
339 template<class ImageType1, class ImageType2>
340 bool HaveSameSizeAndSpacing(typename ImageType1::Pointer A, 
341                            typename ImageType2::Pointer B) 
342 {
343   if (A->GetImageDimension() != B->GetImageDimension()) return false;
344   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
345     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
346     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
347   }
348   return true;
349 }
350 //--------------------------------------------------------------------
351
352 //--------------------------------------------------------------------
353 template<class ImageType1, class ImageType2>
354 bool HaveSameSpacing(typename ImageType1::ConstPointer A, 
355                      typename ImageType2::ConstPointer B) 
356 {
357   if (A->GetImageDimension() != B->GetImageDimension()) return false;
358   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
359     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
360   }
361   return true;
362 }
363 //--------------------------------------------------------------------
364
365 //--------------------------------------------------------------------
366 template<class ImageType1, class ImageType2>
367 bool HaveSameSpacing(typename ImageType1::Pointer A, 
368                            typename ImageType2::Pointer B) 
369 {
370   if (A->GetImageDimension() != B->GetImageDimension()) return false;
371   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
372     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
373   }
374   return true;
375 }
376 //--------------------------------------------------------------------
377
378 #endif /* end #define CLITKIMAGECOMMON_TXX */
379