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