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