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