]> Creatis software - clitk.git/blob - common/clitkImageCommon.txx
hide inputselector option
[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 template<class ImageType>
186 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose)
187 {
188   typedef itk::ImageFileWriter<ImageType> WriterType;
189   typename WriterType::Pointer writer = WriterType::New();
190   writer->SetFileName(filename.c_str());
191   writer->SetInput(image);
192   if (verbose) {
193     std::cout << "Writing [" << filename << "] ... " << std::endl;
194   }
195   try {
196     writer->Update();
197   } catch( itk::ExceptionObject & err ) {
198     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
199     std::cerr << err << std::endl;
200     exit(-1);
201   }
202 }
203 //--------------------------------------------------------------------
204
205 //--------------------------------------------------------------------
206 template<class ImageType>
207 void writeImage(const ImageType* image, const std::string & filename, const bool verbose)
208 {
209   typedef itk::ImageFileWriter<ImageType> WriterType;
210   typename WriterType::Pointer writer = WriterType::New();
211   writer->SetFileName(filename.c_str());
212   writer->SetInput(image);
213   if (verbose) {
214     std::cout << "Writing [" << filename << "] ... " << std::endl;
215   }
216   try {
217     writer->Update();
218   } catch( itk::ExceptionObject & err ) {
219     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
220     std::cerr << err << std::endl;
221     exit(-1);
222   }
223 }
224 // //--------------------------------------------------------------------
225
226 // //--------------------------------------------------------------------
227 // template<class ImageType>
228 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
229 //   typedef itk::ImageFileWriter<ImageType> WriterType;
230 //   typename WriterType::Pointer writer = WriterType::New();
231 //   writer->SetFileName(filename.c_str());
232 //   writer->SetInput(image);
233 //   if (verbose) {
234 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
235 //   }
236 //   try {
237 //     writer->Update();
238 //   }
239 //   catch( itk::ExceptionObject & err ) {
240 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
241 //     std::cerr << err << std::endl;
242 //     exit(-1);
243 //   }
244 // }
245
246 //--------------------------------------------------------------------
247
248 //--------------------------------------------------------------------
249 // Compute the number of different intensities in an image
250 template<class ImageType>
251 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
252                                      std::vector<typename ImageType::PixelType> & l)
253 {
254   //std::set<typename ImageType::PixelType> listOfIntensities;
255   std::map<typename ImageType::PixelType, bool> listOfIntensities;
256   //  listOfIntensities.resize(0);
257   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
258   ConstIteratorType pi(image, image->GetLargestPossibleRegion());
259   pi.Begin();
260   while (!pi.IsAtEnd()) {
261     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
262     // if (std::find(listOfIntensities.begin(),
263     //                            listOfIntensities.end(),
264     //                            pi.Get()) == listOfIntensities.end()) {
265     //    listOfIntensities.insert(pi.Get());
266     //  }
267     ++pi;
268   }
269
270   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
271   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
272   while (ppi != listOfIntensities.end()) {
273     l.push_back(ppi->first);
274     ++ppi;
275   }
276
277   return listOfIntensities.size();
278 }
279 //--------------------------------------------------------------------
280
281 //--------------------------------------------------------------------
282 template<class InputImageType, class MaskImageType>
283 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
284                                  const typename MaskImageType::Pointer & mask,
285                                  const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
286                                  std::map<typename MaskImageType::PixelType,
287                                  std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
288 {
289   // Check size
290   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
291     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
292                              << std::endl
293                              << "Input = " << input->GetLargestPossibleRegion()
294                              << std::endl
295                              << "Mask = " << mask->GetLargestPossibleRegion());
296   }
297
298   // reset weights list
299   mapOfLabelsAndWeights.clear();
300
301   // loop
302   typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
303   ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
304   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
305   ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
306   pi.Begin();
307   pm.Begin();
308   while (!pi.IsAtEnd()) {
309     mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
310     ++pi;
311     ++pm;
312   }
313 }
314 //--------------------------------------------------------------------
315
316 #endif /* end #define CLITKIMAGECOMMON_TXX */
317