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