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