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