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