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