]> Creatis software - clitk.git/blob - common/vvImage.cxx
itk4.3 compatibility
[clitk.git] / common / vvImage.cxx
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 VVIMAGE_CXX
19 #define VVIMAGE_CXX
20
21 // vv
22 #include "vvImage.h"
23
24 // clitk
25 #include "clitkCommon.h"
26
27 // vtk
28 #include <vtkImageData.h>
29 #include <vtkTransform.h>
30
31 // std
32 #include <cassert>
33
34 //--------------------------------------------------------------------
35 vvImage::vvImage()
36 {
37   Init();
38 }
39 //--------------------------------------------------------------------
40
41
42 //--------------------------------------------------------------------
43 void vvImage::Init()
44 {
45   mTimeSpacing = 1;
46   mTimeOrigin = 0;
47   mImageDimension = 0;
48 }
49 //--------------------------------------------------------------------
50
51 //--------------------------------------------------------------------
52 vvImage::~vvImage()
53 {
54   Reset();
55 }
56 //--------------------------------------------------------------------
57
58 //--------------------------------------------------------------------
59 void vvImage::Reset()
60 {
61   mVtkImages.clear();
62   Init();
63 }
64 //--------------------------------------------------------------------
65
66 //--------------------------------------------------------------------
67 void vvImage::AddVtkImage(vtkImageData* input)
68 {
69   // RP: 20/12/2011
70   // Note that we're simply adding a new image to the vector.
71   // mItkToVtkConverters is therefore not being updated, but 
72   // up to here it's not being used anyway...
73   mImageDimension = 0;
74   int* extent = input->GetWholeExtent();
75   if (extent[4] != extent[5])
76     mImageDimension = 3;
77   else if (extent[3] != extent[4])
78     mImageDimension = 2;
79   else if (extent[0] != extent[1])
80     mImageDimension = 1;
81   
82   mVtkImages.push_back(input);
83 }
84
85 //--------------------------------------------------------------------
86
87 //--------------------------------------------------------------------
88 int vvImage::GetNumberOfSpatialDimensions()
89 {
90   return mImageDimension;
91 }
92 //--------------------------------------------------------------------
93
94 //--------------------------------------------------------------------
95 int vvImage::GetNumberOfDimensions() const
96 {
97   if (mVtkImages.size()) {
98     if (IsTimeSequence())
99       return mImageDimension+1;
100     else
101       return mImageDimension;
102   }
103   return 0;
104 }
105 //--------------------------------------------------------------------
106
107 //--------------------------------------------------------------------
108 void vvImage::GetScalarRange(double* range)
109 {
110   assert(mVtkImages.size());
111   double * temp = mVtkImages[0]->GetScalarRange();
112   range[0]=temp[0];
113   range[1]=temp[1];
114   for (unsigned int i=1; i<mVtkImages.size(); i++) {
115     temp = mVtkImages[i]->GetScalarRange();
116     if (temp[0] < range[0]) range[0]=temp[0];
117     if (temp[1] > range[1]) range[1]=temp[1];
118   }
119 }
120 //--------------------------------------------------------------------
121
122 //--------------------------------------------------------------------
123 std::string vvImage::GetScalarTypeAsITKString()
124 {
125   // WARNING VTK pixel type different from ITK Pixel type
126   std::string vtktype = mVtkImages[0]->GetScalarTypeAsString();
127   if (vtktype == "unsigned char") return "unsigned_char";
128   if (vtktype == "unsigned short") return "unsigned_short";
129   if (vtktype == "unsigned int") return "unsigned_int";
130   return vtktype;
131 }
132 //--------------------------------------------------------------------
133
134 //--------------------------------------------------------------------
135 int vvImage::GetNumberOfScalarComponents()
136 {
137   return mVtkImages[0]->GetNumberOfScalarComponents();
138 }
139 //--------------------------------------------------------------------
140
141 //--------------------------------------------------------------------
142 int vvImage::GetScalarSize()
143 {
144   return mVtkImages[0]->GetScalarSize();
145 }
146 //--------------------------------------------------------------------
147
148 //--------------------------------------------------------------------
149 std::vector<double> vvImage::GetSpacing()
150 {
151   std::vector<double> spacing;
152   int dim = this->GetNumberOfDimensions();
153   for (int i = 0; i < dim; i++) {
154     if (i == 3)
155       spacing.push_back(mTimeSpacing);
156     else
157       spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
158   }
159   return spacing;
160 }
161 //--------------------------------------------------------------------
162 std::vector<double> vvImage::GetOrigin() const
163 {
164   std::vector<double> origin;
165   int dim = this->GetNumberOfDimensions();
166   for (int i = 0; i < dim; i++) {
167     if (i == 3)
168       origin.push_back(mTimeOrigin);
169     else
170       origin.push_back(mVtkImages[0]->GetOrigin()[i]);
171   }
172   return origin;
173 }
174 //--------------------------------------------------------------------
175
176 //--------------------------------------------------------------------
177 std::vector<int> vvImage::GetSize()
178 {
179   std::vector<int> size0;
180   int dim = this->GetNumberOfDimensions();
181   for (int i = 0; i < dim; i++) {
182     if (i == 3)
183       size0.push_back(mVtkImages.size());
184     else
185       size0.push_back(mVtkImages[0]->GetDimensions()[i]);
186   }
187   return size0;
188 }
189 //--------------------------------------------------------------------
190
191 //--------------------------------------------------------------------
192 unsigned long vvImage::GetActualMemorySize()
193 {
194   unsigned long size = 0;
195   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
196     size += mVtkImages[i]->GetActualMemorySize();
197   }
198   return size;
199 }
200 //--------------------------------------------------------------------
201
202
203 //--------------------------------------------------------------------
204 bool vvImage::IsTimeSequence() const
205 {
206   return mVtkImages.size()>1;
207 }
208 //--------------------------------------------------------------------
209
210
211 //--------------------------------------------------------------------
212 const std::vector<vtkImageData*>& vvImage::GetVTKImages()
213 {
214   return mVtkImages;
215 }
216 //--------------------------------------------------------------------
217
218 //--------------------------------------------------------------------
219 vtkImageData* vvImage::GetFirstVTKImageData()
220 {
221   return mVtkImages[0];
222 }
223 //--------------------------------------------------------------------
224
225 //--------------------------------------------------------------------
226 bool vvImage::IsScalarTypeInteger()
227 {
228   assert(mVtkImages.size()> 0);
229   int t = mVtkImages[0]->GetScalarType();
230   return IsScalarTypeInteger(t);
231 }
232 //--------------------------------------------------------------------
233
234 //--------------------------------------------------------------------
235 bool vvImage::IsScalarTypeInteger(int t)
236 {
237   if ((t == VTK_BIT) ||
238       (t == VTK_CHAR) ||
239       (t == VTK_UNSIGNED_CHAR) ||
240       (t == VTK_SHORT) ||
241       (t == VTK_UNSIGNED_SHORT) ||
242       (t == VTK_INT) ||
243       (t == VTK_UNSIGNED_INT) ||
244       (t == VTK_LONG) ||
245       (t == VTK_UNSIGNED_LONG))    {
246     return true;
247   } else {
248     return false;
249   }
250 }
251 //--------------------------------------------------------------------
252
253 //--------------------------------------------------------------------
254 const std::vector< vtkSmartPointer<vtkTransform> >& vvImage::GetTransform()
255 {
256   return this->mTransform;
257 }
258 //--------------------------------------------------------------------
259
260
261 //--------------------------------------------------------------------
262 bool vvImage::HaveSameSizeAndSpacingThan(vvImage * other)
263 {
264   bool same = true;
265   for(int i=0; i<GetNumberOfDimensions(); i++) {
266     if ( GetSize()[i] != other->GetSize()[i]) same = false;
267     if ( GetSpacing()[i] != other->GetSpacing()[i]) same = false;
268   }
269   return same;
270 }
271 //--------------------------------------------------------------------
272
273
274 #endif // VVIMAGE_CXX