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