]> Creatis software - clitk.git/blob - common/clitkImageCommon.txx
Merge branch 'master' into extentSimon
[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://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 #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, const bool compression)
192 {
193   return writeImage(image.GetPointer(), filename, verbose, compression);
194 }
195 //--------------------------------------------------------------------
196
197
198 //--------------------------------------------------------------------
199 template<class ImageType>
200 void writeImage(const ImageType* image, const std::string & filename, const bool verbose, const bool compression)
201 {
202   typedef itk::ImageFileWriter<ImageType> WriterType;
203   typename WriterType::Pointer writer = WriterType::New();
204   writer->SetFileName(filename.c_str());
205   writer->SetInput(image);
206   writer->SetUseCompression(compression);
207   if (verbose) {
208     std::cout << "Writing [" << filename << "] ... " << std::endl;
209   }
210   try {
211     writer->Update();
212   } catch( itk::ExceptionObject & err ) {
213     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
214     std::cerr << err << std::endl;
215     exit(-1);
216   }
217 }
218 // //--------------------------------------------------------------------
219
220 // //--------------------------------------------------------------------
221 // template<class ImageType>
222 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
223 //   typedef itk::ImageFileWriter<ImageType> WriterType;
224 //   typename WriterType::Pointer writer = WriterType::New();
225 //   writer->SetFileName(filename.c_str());
226 //   writer->SetInput(image);
227 //   if (verbose) {
228 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
229 //   }
230 //   try {
231 //     writer->Update();
232 //   }
233 //   catch( itk::ExceptionObject & err ) {
234 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
235 //     std::cerr << err << std::endl;
236 //     exit(-1);
237 //   }
238 // }
239
240 //--------------------------------------------------------------------
241
242 //--------------------------------------------------------------------
243 // Compute the number of different intensities in an image
244 template<class ImageType>
245 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
246                                      std::vector<typename ImageType::PixelType> & l)
247 {
248   //std::set<typename ImageType::PixelType> listOfIntensities;
249   std::map<typename ImageType::PixelType, bool> listOfIntensities;
250   //  listOfIntensities.resize(0);
251   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
252   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
253   pi.Begin();
254   while (!pi.IsAtEnd()) {
255     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
256     // if (std::find(listOfIntensities.begin(),
257     //                            listOfIntensities.end(),
258     //                            pi.Get()) == listOfIntensities.end()) {
259     //    listOfIntensities.insert(pi.Get());
260     //  }
261     ++pi;
262   }
263
264   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
265   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
266   while (ppi != listOfIntensities.end()) {
267     l.push_back(ppi->first);
268     ++ppi;
269   }
270
271   return listOfIntensities.size();
272 }
273 //--------------------------------------------------------------------
274
275
276 //--------------------------------------------------------------------
277 template<class InputImageType, class MaskImageType>
278 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
279                                  const typename MaskImageType::Pointer & mask,
280                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
281                                  std::map<typename MaskImageType::PixelType,
282                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
283 {
284   // Check size
285   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
286     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
287                              << std::endl
288                              << "Input = " << input->GetLargestPossibleRegion()
289                              << std::endl
290                              << "Mask = " << mask->GetLargestPossibleRegion());
291   }
292
293   // reset weights list
294   mapOfLabelsAndWeights.clear();
295
296   // loop
297   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
298   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
299   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
300   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
301   pi.Begin();
302   pm.Begin();
303   while (!pi.IsAtEnd()) {
304     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
305     ++pi;
306     ++pm;
307   }
308 }
309 //--------------------------------------------------------------------
310
311
312 //--------------------------------------------------------------------
313 template<class ImageType1, class ImageType2>
314 bool HaveSameSpacing(typename ImageType1::ConstPointer A,
315                      typename ImageType2::ConstPointer B)
316 {
317   if (A->GetImageDimension() != B->GetImageDimension()) return false;
318   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
319     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
320   }
321   return true;
322 }
323 //--------------------------------------------------------------------
324
325 //--------------------------------------------------------------------
326 template<class ImageType1, class ImageType2>
327 bool HaveSameSpacing(typename ImageType1::Pointer A,
328                      typename ImageType2::Pointer B)
329 {
330   if (A->GetImageDimension() != B->GetImageDimension()) return false;
331   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
332     if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
333   }
334   return true;
335 }
336 //--------------------------------------------------------------------
337
338 //--------------------------------------------------------------------
339 template<class ImageType1, class ImageType2>
340 bool HaveSameSize(typename ImageType1::ConstPointer A,
341                   typename ImageType2::ConstPointer B)
342 {
343   if (A->GetImageDimension() != B->GetImageDimension()) return false;
344   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
345     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
346   }
347   return true;
348 }
349 //--------------------------------------------------------------------
350
351 //--------------------------------------------------------------------
352 template<class ImageType1, class ImageType2>
353 bool HaveSameSize(typename ImageType1::Pointer A,
354                   typename ImageType2::Pointer B)
355 {
356   if (A->GetImageDimension() != B->GetImageDimension()) return false;
357   for(unsigned int i=0; i<A->GetImageDimension(); i++) {
358     if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
359   }
360   return true;
361 }
362 //--------------------------------------------------------------------
363
364 //--------------------------------------------------------------------
365 template<class ImageType1, class ImageType2>
366 bool HaveSameSizeAndSpacing(typename ImageType1::ConstPointer A,
367                             typename ImageType2::ConstPointer B)
368 {
369   return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
370            HaveSameSpacing<ImageType1, ImageType2>(A, B) );
371 }
372 //--------------------------------------------------------------------
373
374 //--------------------------------------------------------------------
375 template<class ImageType1, class ImageType2>
376 bool HaveSameSizeAndSpacing(typename ImageType1::Pointer A,
377                             typename ImageType2::Pointer B)
378 {
379   return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
380            HaveSameSpacing<ImageType1, ImageType2>(A, B) );
381 }
382 //--------------------------------------------------------------------
383
384 #endif /* end #define CLITKIMAGECOMMON_TXX */
385