1 /*=========================================================================
2 Program: vv http://www.creatis.insa-lyon.fr/rio/vv
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
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.
13 It is distributed under dual licence
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
22 //--------------------------------------------------------------------
23 template<class PixelType>
24 typename itk::Image<PixelType,1>::Pointer NewImage1D(int vsize, double vspacing) {
25 typedef itk::Image<PixelType,1> ImageType;
26 typename ImageType::Pointer g = ImageType::New();
27 typename ImageType::SizeType size;
29 typename ImageType::RegionType region;
31 g->SetRegions(region);
32 typename ImageType::SpacingType spacing;
33 spacing[0] = vspacing;
34 g->SetSpacing(spacing);
37 //--------------------------------------------------------------------
39 //--------------------------------------------------------------------
40 template<class PixelType>
41 typename itk::Image<PixelType,2>::Pointer NewImage2D(int sx, int sy, double dx, double dy) {
42 typedef itk::Image<PixelType,2> ImageType;
43 typename ImageType::Pointer g = ImageType::New();
44 typename ImageType::SizeType size;
45 size[0] = sx; size[1] = sy;
46 typename ImageType::RegionType region;
48 g->SetRegions(region);
49 typename ImageType::SpacingType spacing;
50 spacing[0] = dx; spacing[1] = dy;
51 g->SetSpacing(spacing);
54 //--------------------------------------------------------------------
56 //--------------------------------------------------------------------
57 template<class PixelType>
58 typename itk::Image<PixelType,3>::Pointer NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz) {
59 typedef itk::Image<PixelType,3> ImageType;
60 typename ImageType::Pointer g = ImageType::New();
61 typename ImageType::SizeType size;
62 size[0] = sx; size[1] = sy; size[2] = sz;
63 typename ImageType::RegionType region;
65 g->SetRegions(region);
66 typename ImageType::SpacingType spacing;
67 spacing[0] = dx; spacing[1] = dy; spacing[2] = dz;
68 g->SetSpacing(spacing);
71 //--------------------------------------------------------------------
73 //--------------------------------------------------------------------
74 template<class PixelType>
75 typename itk::Image<PixelType,4>::Pointer NewImage4D(int sx, int sy, int sz, int st, double dx, double dy, double dz, double dt) {
76 typedef itk::Image<PixelType,3> ImageType;
77 typename ImageType::Pointer g = ImageType::New();
78 typename ImageType::SizeType size;
79 size[0] = sx; size[1] = sy; size[2] = sz; size[3] = st;
80 typename ImageType::RegionType region;
82 g->SetRegions(region);
83 typename ImageType::SpacingType spacing;
84 spacing[0] = dx; spacing[1] = dy; spacing[2] = dz; spacing[3] = dt;
85 g->SetSpacing(spacing);
88 //--------------------------------------------------------------------
91 //--------------------------------------------------------------------
92 template<class ImageType>
93 typename ImageType::Pointer NewImageLike(const typename ImageType::Pointer input, bool allocate) {
94 typename ImageType::Pointer output = ImageType::New();
95 output->CopyInformation(input);
96 output->SetRegions(input->GetLargestPossibleRegion());
97 if (allocate) output->Allocate();
100 //--------------------------------------------------------------------
103 //--------------------------------------------------------------------
104 template<class ImageType>
105 void CopyValues(const typename ImageType::Pointer input,
106 typename ImageType::Pointer output) {
107 typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
108 ConstIteratorType pi(input,input->GetLargestPossibleRegion());
110 typedef itk::ImageRegionIterator<ImageType> IteratorType;
111 IteratorType po(output,input->GetLargestPossibleRegion());
113 while (!pi.IsAtEnd()) {
119 //--------------------------------------------------------------------
122 //--------------------------------------------------------------------
123 template<class ImageType>
124 typename ImageType::Pointer readImage(const std::string & filename, const bool verbose) {
125 typedef itk::ImageFileReader<ImageType> ReaderType;
126 typename ReaderType::Pointer reader = ReaderType::New();
127 reader->SetFileName(filename.c_str());
129 std::cout << "Reading [" << filename << "] ... " << std::endl;
134 catch(itk::ExceptionObject & err) {
135 std::cerr << "Exception while reading image [" << filename << "]" << std::endl;
136 std::cerr << err << std::endl;
139 return reader->GetOutput();
141 //--------------------------------------------------------------------
143 //--------------------------------------------------------------------
144 template<typename ImageType>
145 typename ImageType::Pointer readImage(const std::vector<std::string> & filenames,
146 const bool verbose) {
147 if (filenames.size() == 1) return readImage<ImageType>(filenames[0], verbose);
148 typedef itk::ImageSeriesReader<ImageType> ReaderType;
149 typename ReaderType::Pointer reader = ReaderType::New();
150 reader->SetFileNames(filenames);
152 std::cout << "Reading " << filenames[0] << " and others ..." << std::endl;
157 catch( itk::ExceptionObject & err ) {
158 std::cerr << "Error while reading " << filenames[0]
159 << " or other files ..." << err << std::endl;
162 return reader->GetOutput();
164 //--------------------------------------------------------------------
166 //--------------------------------------------------------------------
167 template<class ImageType>
168 void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose) {
169 typedef itk::ImageFileWriter<ImageType> WriterType;
170 typename WriterType::Pointer writer = WriterType::New();
171 writer->SetFileName(filename.c_str());
172 writer->SetInput(image);
174 std::cout << "Writing [" << filename << "] ... " << std::endl;
179 catch( itk::ExceptionObject & err ) {
180 std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
181 std::cerr << err << std::endl;
185 //--------------------------------------------------------------------
187 //--------------------------------------------------------------------
188 template<class ImageType>
189 void writeImage(const ImageType* image, const std::string & filename, const bool verbose) {
190 typedef itk::ImageFileWriter<ImageType> WriterType;
191 typename WriterType::Pointer writer = WriterType::New();
192 writer->SetFileName(filename.c_str());
193 writer->SetInput(image);
195 std::cout << "Writing [" << filename << "] ... " << std::endl;
200 catch( itk::ExceptionObject & err ) {
201 std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
202 std::cerr << err << std::endl;
206 // //--------------------------------------------------------------------
208 // //--------------------------------------------------------------------
209 // template<class ImageType>
210 // void writeImage(const typename ImageType::ConstPointer image, const std::string & filename, const bool verbose=false) {
211 // typedef itk::ImageFileWriter<ImageType> WriterType;
212 // typename WriterType::Pointer writer = WriterType::New();
213 // writer->SetFileName(filename.c_str());
214 // writer->SetInput(image);
216 // std::cout << "Writing [" << filename << "] ... " << std::endl;
221 // catch( itk::ExceptionObject & err ) {
222 // std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
223 // std::cerr << err << std::endl;
228 //--------------------------------------------------------------------
230 //--------------------------------------------------------------------
231 // Compute the number of different intensities in an image
232 template<class ImageType>
233 int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
234 std::vector<typename ImageType::PixelType> & l)
236 //std::set<typename ImageType::PixelType> listOfIntensities;
237 std::map<typename ImageType::PixelType, bool> listOfIntensities;
238 // listOfIntensities.resize(0);
239 typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
240 ConstIteratorType pi(image, image->GetLargestPossibleRegion());
242 while (!pi.IsAtEnd()) {
243 if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
244 // if (std::find(listOfIntensities.begin(),
245 // listOfIntensities.end(),
246 // pi.Get()) == listOfIntensities.end()) {
247 // listOfIntensities.insert(pi.Get());
252 //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
253 typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
254 while (ppi != listOfIntensities.end()) {
255 l.push_back(ppi->first);
259 return listOfIntensities.size();
261 //--------------------------------------------------------------------
263 //--------------------------------------------------------------------
264 template<class InputImageType, class MaskImageType>
265 void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
266 const typename MaskImageType::Pointer & mask,
267 const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
268 std::map<typename MaskImageType::PixelType,
269 std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights) {
271 if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
272 itkGenericExceptionMacro(<< "Input and mask images have not the same size"
274 << "Input = " << input->GetLargestPossibleRegion()
276 << "Mask = " << mask->GetLargestPossibleRegion());
279 // reset weights list
280 mapOfLabelsAndWeights.clear();
283 typedef itk::ImageRegionConstIterator<InputImageType> ConstInputIteratorType;
284 ConstInputIteratorType pi(input, input->GetLargestPossibleRegion());
285 typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
286 ConstMaskIteratorType pm(mask, mask->GetLargestPossibleRegion());
289 while (!pi.IsAtEnd()) {
290 mapOfLabelsAndWeights[pm.Get()][pi.Get()]++;
295 //--------------------------------------------------------------------
297 #endif /* end #define CLITKIMAGECOMMON_TXX */