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, vtkSmartPointer<vtkTransform> transform)
  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   mTransform.push_back(transform);
  94 }
  95
  96 //--------------------------------------------------------------------
  97
  98 //--------------------------------------------------------------------
  99 int vvImage::GetNumberOfSpatialDimensions()
 100 {
 101   return mImageDimension;
 102 }
 103 //--------------------------------------------------------------------
 104
 105 //--------------------------------------------------------------------
 106 int vvImage::GetNumberOfDimensions() const
 107 {
 108   if (mVtkImages.size()) {
 109     if (IsTimeSequence())
 110       return mImageDimension+1;
 111     else
 112       return mImageDimension;
 113   }
 114   return 0;
 115 }
 116 //--------------------------------------------------------------------
 117
 118 //--------------------------------------------------------------------
 119 void vvImage::GetScalarRange(double* range)
 120 {
 121   range[0]=mrange[0];
 122   range[1]=mrange[1];
 123 }
 124 //--------------------------------------------------------------------
 125
 126 //--------------------------------------------------------------------
 127 std::string vvImage::GetScalarTypeAsITKString()
 128 {
 129   // WARNING VTK pixel type different from ITK Pixel type
 130   std::string vtktype = mVtkImages[0]->GetScalarTypeAsString();
 131   if (vtktype == "unsigned char") return "unsigned_char";
 132   if (vtktype == "unsigned short") return "unsigned_short";
 133   if (vtktype == "unsigned int") return "unsigned_int";
 134   return vtktype;
 135 }
 136 //--------------------------------------------------------------------
 137
 138 //--------------------------------------------------------------------
 139 int vvImage::GetNumberOfScalarComponents()
 140 {
 141   return mVtkImages[0]->GetNumberOfScalarComponents();
 142 }
 143 //--------------------------------------------------------------------
 144
 145 //--------------------------------------------------------------------
 146 int vvImage::GetScalarSize()
 147 {
 148   return mVtkImages[0]->GetScalarSize();
 149 }
 150 //--------------------------------------------------------------------
 151
 152 //--------------------------------------------------------------------
 153 std::vector<double> vvImage::GetSpacing()
 154 {
 155   std::vector<double> spacing;
 156   int dim = this->GetNumberOfDimensions();
 157   for (int i = 0; i < dim; i++) {
 158     if (i == 3)
 159       spacing.push_back(mTimeSpacing);
 160     else
 161       spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
 162   }
 163   return spacing;
 164 }
 165 //--------------------------------------------------------------------
 166 std::vector<double> vvImage::GetOrigin() const
 167 {
 168   std::vector<double> origin;
 169   int dim = this->GetNumberOfDimensions();
 170   for (int i = 0; i < dim; i++) {
 171     if (i == 3)
 172       origin.push_back(mTimeOrigin);
 173     else
 174       origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 175   }
 176   return origin;
 177 }
 178 //--------------------------------------------------------------------
 179
 180 //--------------------------------------------------------------------
 181 std::vector<int> vvImage::GetSize()
 182 {
 183   std::vector<int> size0;
 184   int dim = this->GetNumberOfDimensions();
 185   for (int i = 0; i < dim; i++) {
 186     if (i == 3)
 187       size0.push_back(mVtkImages.size());
 188     else
 189       size0.push_back(mVtkImages[0]->GetDimensions()[i]);
 190   }
 191   return size0;
 192 }
 193 //--------------------------------------------------------------------
 194
 195 //--------------------------------------------------------------------
 196 unsigned long vvImage::GetActualMemorySize()
 197 {
 198   unsigned long size = 0;
 199   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
 200     size += mVtkImages[i]->GetActualMemorySize()*1024;
 201   }
 202   return size;
 203 }
 204 //--------------------------------------------------------------------
 205
 206
 207 //--------------------------------------------------------------------
 208 bool vvImage::IsTimeSequence() const
 209 {
 210   return mVtkImages.size()>1;
 211 }
 212 //--------------------------------------------------------------------
 213
 214
 215 //--------------------------------------------------------------------
 216 const std::vector<vtkImageData*>& vvImage::GetVTKImages()
 217 {
 218   return mVtkImages;
 219 }
 220 //--------------------------------------------------------------------
 221
 222 //--------------------------------------------------------------------
 223 vtkImageData* vvImage::GetFirstVTKImageData()
 224 {
 225   return mVtkImages[0];
 226 }
 227 //--------------------------------------------------------------------
 228
 229 //--------------------------------------------------------------------
 230 bool vvImage::IsScalarTypeInteger()
 231 {
 232   assert(mVtkImages.size()> 0);
 233   int t = mVtkImages[0]->GetScalarType();
 234   return IsScalarTypeInteger(t);
 235 }
 236 //--------------------------------------------------------------------
 237
 238 //--------------------------------------------------------------------
 239 bool vvImage::IsScalarTypeInteger(int t)
 240 {
 241   if ((t == VTK_BIT) ||
 242       (t == VTK_CHAR) ||
 243       (t == VTK_UNSIGNED_CHAR) ||
 244       (t == VTK_SHORT) ||
 245       (t == VTK_UNSIGNED_SHORT) ||
 246       (t == VTK_INT) ||
 247       (t == VTK_UNSIGNED_INT) ||
 248       (t == VTK_LONG) ||
 249       (t == VTK_UNSIGNED_LONG))    {
 250     return true;
 251   } else {
 252     return false;
 253   }
 254 }
 255 //--------------------------------------------------------------------
 256
 257 //--------------------------------------------------------------------
 258 const std::vector< vtkSmartPointer<vtkTransform> >& vvImage::GetTransform()
 259 {
 260   return this->mTransform;
 261 }
 262 //--------------------------------------------------------------------
 263
 264
 265 //--------------------------------------------------------------------
 266 void vvImage::InitializeTransform()
 267 {
 268   for (int i = 0; i < mTransform.size(); i++)
 269     mTransform[i]->Identity();
 270 }
 271 //--------------------------------------------------------------------
 272
 273
 274 //--------------------------------------------------------------------
 275 std::vector< std::vector<double> > vvImage::GetDirection()
 276 {
 277   int dim = this->GetNumberOfDimensions();
 278   vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
 279   transform->Identity();
 280   for (int i = 0; i < mTransform.size(); i++)
 281     transform->Concatenate(this->mTransform[i]);
 282
 283   vtkSmartPointer<vtkMatrix4x4> matrix = transform->GetMatrix();
 284   matrix->Invert();
 285   std::vector<std::vector<double> > direction0;
 286   for (int i = 0; i < dim; i++) {
 287     if (i != 3) {
 288       std::vector<double> direction1;
 289       for (int j = 0; j < dim; j++) {
 290         if (j != 3)
 291 #if VTK_MAJOR_VERSION <= 6
 292           direction1.push_back((*matrix)[i][j]);
 293 #else
 294           direction1.push_back((*matrix).GetElement(i,j));
 295 #endif
 296       }
 297       direction0.push_back(direction1);
 298     }
 299   }
 300   return direction0;
 301 }
 302 //--------------------------------------------------------------------
 303
 304
 305
 306 //--------------------------------------------------------------------
 307 bool vvImage::HaveSameSizeAndSpacingThan(vvImage * other)
 308 {
 309   bool same = true;
 310   for(int i=0; i<GetNumberOfDimensions(); i++) {
 311     if ( GetSize()[i] != other->GetSize()[i]) same = false;
 312     if ( GetSpacing()[i] != other->GetSpacing()[i]) same = false;
 313   }
 314   return same;
 315 }
 316 //--------------------------------------------------------------------
 317 itk::MetaDataDictionary* vvImage::GetFirstMetaDataDictionary()
 318 {
 319     return mDictionary[0];
 320 }
 321 //--------------------------------------------------------------------
 322
 323
 324 #endif // VVIMAGE_CXX