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