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