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 <vtkTransform.h>
  23 #include <vtkImageData.h>
  24 #include <vtkImageReslice.h>
  25 #include <cassert>
  26
  27 //--------------------------------------------------------------------
  28 vvImage::vvImage()
  29 {
  30   Init();
  31 }
  32 //--------------------------------------------------------------------
  33
  34
  35 //--------------------------------------------------------------------
  36 void vvImage::Init()
  37 {
  38   mTimeSpacing = 1;
  39   mTimeOrigin = 0;
  40
  41   if (CLITK_EXPERIMENTAL)
  42     mTransform = vtkSmartPointer<vtkTransform>::New();
  43 }
  44 //--------------------------------------------------------------------
  45
  46 //--------------------------------------------------------------------
  47 vvImage::~vvImage()
  48 {
  49   Reset();
  50 }
  51 //--------------------------------------------------------------------
  52
  53 //--------------------------------------------------------------------
  54 void vvImage::Reset()
  55 {
  56   if (CLITK_EXPERIMENTAL)
  57     for (unsigned int i = 0; i < mVtkImages.size(); i++)
  58       mVtkImageReslice[i]->GetInput(0)->Delete();
  59   else
  60     for (unsigned int i = 0; i < mVtkImages.size(); i++)
  61       mVtkImages[i]->Delete();
  62
  63   mVtkImages.resize(0);
  64   mVtkImageReslice.resize(0);
  65
  66   Init();
  67 }
  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   if (CLITK_EXPERIMENTAL) {
  85     mVtkImageReslice.push_back(vtkSmartPointer<vtkImageReslice>::New());
  86
  87     mVtkImageReslice.back()->SetInterpolationModeToLinear();
  88     mVtkImageReslice.back()->AutoCropOutputOn();
  89     mVtkImageReslice.back()->SetBackgroundColor(-1000,-1000,-1000,1);
  90     mVtkImageReslice.back()->SetResliceTransform(mTransform);
  91     mVtkImageReslice.back()->SetInput(0, image);
  92     mVtkImageReslice.back()->Update();
  93
  94     mVtkImages.push_back( mVtkImageReslice.back()->GetOutput(0) );
  95   } else
  96     mVtkImages.push_back(image);
  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 void vvImage::GetScalarRange(double* range)
 128 {
 129   assert(mVtkImages.size());
 130   double * temp = mVtkImages[0]->GetScalarRange();
 131   range[0]=temp[0];
 132   range[1]=temp[1];
 133   for (unsigned int i=1; i<mVtkImages.size(); i++) {
 134     temp = mVtkImages[i]->GetScalarRange();
 135     if (temp[0] < range[0]) range[0]=temp[0];
 136     if (temp[1] > range[1]) range[1]=temp[1];
 137   }
 138 }
 139
 140 //--------------------------------------------------------------------
 141 std::string vvImage::GetScalarTypeAsString()
 142 {
 143   // WARNING VTK pixel type different from ITK Pixel type
 144   std::string vtktype = mVtkImages[0]->GetScalarTypeAsString();
 145   if (vtktype == "unsigned char") return "unsigned_char";
 146   if (vtktype == "unsigned short") return "unsigned_short";
 147   if (vtktype == "unsigned int") return "unsigned_int";
 148   return vtktype;
 149 }
 150 //--------------------------------------------------------------------
 151
 152 //--------------------------------------------------------------------
 153 int vvImage::GetNumberOfScalarComponents()
 154 {
 155   return mVtkImages[0]->GetNumberOfScalarComponents();
 156 }
 157 //--------------------------------------------------------------------
 158
 159 //--------------------------------------------------------------------
 160 int vvImage::GetScalarSize()
 161 {
 162   return mVtkImages[0]->GetScalarSize();
 163 }
 164 //--------------------------------------------------------------------
 165
 166 //--------------------------------------------------------------------
 167 std::vector<double> vvImage::GetSpacing()
 168 {
 169   std::vector<double> spacing;
 170   int dim = this->GetNumberOfDimensions();
 171   for (int i = 0; i < dim; i++) {
 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 std::vector<double> vvImage::GetOrigin() const
 183 {
 184   std::vector<double> origin;
 185   int dim = this->GetNumberOfDimensions();
 186   for (int i = 0; i < dim; i++) {
 187     if (i == 3)
 188       origin.push_back(mTimeOrigin);
 189     else
 190       origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 191   }
 192   return origin;
 193 }
 194 //--------------------------------------------------------------------
 195
 196 //--------------------------------------------------------------------
 197 std::vector<int> vvImage::GetSize()
 198 {
 199   std::vector<int> size0;
 200   int dim = this->GetNumberOfDimensions();
 201   for (int i = 0; i < dim; i++) {
 202     if (i == 3)
 203       size0.push_back(mVtkImages.size());
 204     else
 205       size0.push_back(mVtkImages[0]->GetDimensions()[i]);
 206   }
 207   return size0;
 208 }
 209 //--------------------------------------------------------------------
 210
 211 //--------------------------------------------------------------------
 212 unsigned long vvImage::GetActualMemorySize()
 213 {
 214   unsigned long size = 0;
 215   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
 216     size += mVtkImages[i]->GetActualMemorySize();
 217   }
 218   return size;
 219 }
 220 //--------------------------------------------------------------------
 221
 222
 223 //--------------------------------------------------------------------
 224 bool vvImage::IsTimeSequence()
 225 {
 226   return mVtkImages.size()>1;
 227 }
 228 //--------------------------------------------------------------------
 229
 230
 231 //--------------------------------------------------------------------
 232 const std::vector<vtkImageData*>& vvImage::GetVTKImages()
 233 {
 234   return mVtkImages;
 235 }
 236 //--------------------------------------------------------------------
 237
 238
 239 //--------------------------------------------------------------------
 240 vtkImageData* vvImage::GetFirstVTKImageData()
 241 {
 242   return mVtkImages[0];
 243 }
 244 //--------------------------------------------------------------------
 245
 246
 247 //--------------------------------------------------------------------
 248 bool vvImage::IsScalarTypeInteger()
 249 {
 250   assert(mVtkImages.size()> 0);
 251   int t = mVtkImages[0]->GetScalarType();
 252   return IsScalarTypeInteger(t);
 253 }
 254 //--------------------------------------------------------------------
 255
 256 //--------------------------------------------------------------------
 257 bool vvImage::IsScalarTypeInteger(int t)
 258 {
 259   if ((t == VTK_BIT) ||
 260       (t == VTK_CHAR) ||
 261       (t == VTK_UNSIGNED_CHAR) ||
 262       (t == VTK_SHORT) ||
 263       (t == VTK_UNSIGNED_SHORT) ||
 264       (t == VTK_INT) ||
 265       (t == VTK_UNSIGNED_INT) ||
 266       (t == VTK_LONG) ||
 267       (t == VTK_UNSIGNED_LONG))    {
 268     return true;
 269   } else {
 270     return false;
 271   }
 272 }
 273
 274 //--------------------------------------------------------------------
 275
 276 //--------------------------------------------------------------------
 277 vtkTransform * vvImage::GetTransform()
 278 {
 279   return mTransform;
 280 }
 281 //--------------------------------------------------------------------
 282
 283 //-------------------------------------------------------------------
 284 void vvImage::SetRotateX(int xvalue)
 285 {
 286   mTransform->PostMultiply();
 287   mTransform->Translate(-origin[0],-origin[1],-origin[2]);
 288   mTransform->RotateX(xvalue);
 289   mTransform->Translate(origin[0],origin[1],origin[2]);
 290 }
 291
 292 //--------------------------------------------------------------------
 293
 294 //-------------------------------------------------------------------
 295 void vvImage::SetRotateY(int yvalue)
 296 {
 297   mTransform->PostMultiply();
 298   mTransform->Translate(-origin[0],-origin[1],-origin[2]);
 299   mTransform->RotateY(yvalue);
 300   mTransform->Translate(origin[0],origin[1],origin[2]);
 301 }
 302 //--------------------------------------------------------------------
 303
 304 //-------------------------------------------------------------------
 305 void vvImage::SetRotateZ(int zvalue)
 306 {
 307   mTransform->PostMultiply();
 308   mTransform->Translate(-origin[0],-origin[1],-origin[2]);
 309   mTransform->RotateZ(zvalue);
 310   mTransform->Translate(origin[0],origin[1],origin[2]);
 311 }
 312 //--------------------------------------------------------------------
 313
 314 //-------------------------------------------------------------------
 315 void vvImage::SetTranslationX(int xvalue)
 316 {
 317   mTransform->Translate(xvalue,0,0);
 318 }
 319 //--------------------------------------------------------------------
 320
 321 //-------------------------------------------------------------------
 322
 323 void vvImage::SetTranslationY(int yvalue)
 324 {
 325   mTransform->Translate(0,yvalue,0);
 326 }
 327 //--------------------------------------------------------------------
 328
 329 //-------------------------------------------------------------------
 330 void vvImage::SetTranslationZ(int zvalue)
 331 {
 332   mTransform->Translate(0,0,zvalue);
 333 }
 334 //-------------------------------------------------------------------
 335
 336 //-------------------------------------------------------------------
 337 void vvImage::SetOrigin(double value[3])
 338 {
 339   origin[0]=value[0];
 340   origin[1]=value[1];
 341   origin[2]=value[2];
 342 }
 343
 344 //--------------------------------------------------------------------
 345 void vvImage::SetTransform(vtkTransform  *transform)
 346 {
 347   mTransform = transform;
 348 }
 349 //--------------------------------------------------------------------
 350
 351 #endif // VVIMAGE_CXX