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 <vtkGeneralTransform.h>
  27 #include <vtkTransform.h>
  28 #include <vtkGridTransform.h>
  29
  30 //--------------------------------------------------------------------
  31 vvImage::vvImage():mGeneralTransform(vtkSmartPointer<vtkGeneralTransform>::New()),
  32                    mTransform       (vtkSmartPointer<vtkTransform>::New()),
  33                    mGridTransform   (vtkSmartPointer<vtkGridTransform>::New())
  34 {
  35   mGeneralTransform->Concatenate(mTransform);
  36   mGeneralTransform->Concatenate(mGridTransform);
  37   Init();
  38 }
  39 //--------------------------------------------------------------------
  40
  41
  42 //--------------------------------------------------------------------
  43 void vvImage::Init()
  44 {
  45   mTimeSpacing = 1;
  46   mTimeOrigin = 0;
  47 }
  48 //--------------------------------------------------------------------
  49
  50 //--------------------------------------------------------------------
  51 vvImage::~vvImage()
  52 {
  53   DD("vvImage got deleted!");
  54   Reset();
  55 }
  56 //--------------------------------------------------------------------
  57
  58 //--------------------------------------------------------------------
  59 void vvImage::Reset()
  60 {
  61   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
  62     mVtkImageReslice[i]->GetInput()->Delete();
  63     mVtkImageReslice[i]->Delete();
  64   }
  65
  66   mVtkImages.resize(0);
  67   mVtkImageReslice.resize(0);
  68
  69   Init();
  70 }
  71 //--------------------------------------------------------------------
  72
  73 //--------------------------------------------------------------------
  74 void vvImage::SetImage(std::vector< vtkImageData* > images)
  75 {
  76   Reset();
  77   for (unsigned int i = 0; i < images.size(); i++)
  78     AddImage(images[i]);
  79 }
  80 //--------------------------------------------------------------------
  81
  82
  83 //--------------------------------------------------------------------
  84 void vvImage::AddImage(vtkImageData* image)
  85 {
  86   mVtkImageReslice.push_back(vtkSmartPointer<vtkImageReslice>::New());
  87
  88   mVtkImageReslice.back()->SetInterpolationModeToLinear();
  89   mVtkImageReslice.back()->AutoCropOutputOn();
  90   mVtkImageReslice.back()->SetBackgroundColor(-1000,-1000,-1000,1);
  91   mVtkImageReslice.back()->SetResliceTransform(mGeneralTransform);
  92   mVtkImageReslice.back()->SetInput(0, image);
  93   mVtkImageReslice.back()->Update();
  94
  95   mVtkImages.push_back( mVtkImageReslice.back()->GetOutput(0) );
  96 }
  97 //--------------------------------------------------------------------
  98
  99 //--------------------------------------------------------------------
 100 int vvImage::GetNumberOfSpatialDimensions()
 101 {
 102   int dim=GetNumberOfDimensions();
 103   if (IsTimeSequence())
 104     return dim-1;
 105   else
 106     return dim;
 107 }
 108 //--------------------------------------------------------------------
 109
 110 //--------------------------------------------------------------------
 111 int vvImage::GetNumberOfDimensions() const
 112 {
 113   if (mVtkImages.size()) {
 114     int dimension = 2;
 115     int extent[6];
 116     mVtkImages[0]->GetWholeExtent(extent);
 117     if (extent[5] - extent[4] >= 1)
 118       dimension++;
 119     if (mVtkImages.size() > 1)
 120       dimension++;
 121     return dimension;
 122   }
 123   return 0;
 124 }
 125 //--------------------------------------------------------------------
 126
 127 //--------------------------------------------------------------------
 128 void vvImage::GetScalarRange(double* range)
 129 {
 130   assert(mVtkImages.size());
 131   double * temp = mVtkImages[0]->GetScalarRange();
 132   range[0]=temp[0];
 133   range[1]=temp[1];
 134   for (unsigned int i=1; i<mVtkImages.size(); i++) {
 135     temp = mVtkImages[i]->GetScalarRange();
 136     if (temp[0] < range[0]) range[0]=temp[0];
 137     if (temp[1] > range[1]) range[1]=temp[1];
 138   }
 139 }
 140 //--------------------------------------------------------------------
 141
 142 //--------------------------------------------------------------------
 143 std::string vvImage::GetScalarTypeAsITKString()
 144 {
 145   // WARNING VTK pixel type different from ITK Pixel type
 146   std::string vtktype = mVtkImages[0]->GetScalarTypeAsString();
 147   if (vtktype == "unsigned char") return "unsigned_char";
 148   if (vtktype == "unsigned short") return "unsigned_short";
 149   if (vtktype == "unsigned int") return "unsigned_int";
 150   return vtktype;
 151 }
 152 //--------------------------------------------------------------------
 153
 154 //--------------------------------------------------------------------
 155 int vvImage::GetNumberOfScalarComponents()
 156 {
 157   return mVtkImages[0]->GetNumberOfScalarComponents();
 158 }
 159 //--------------------------------------------------------------------
 160
 161 //--------------------------------------------------------------------
 162 int vvImage::GetScalarSize()
 163 {
 164   return mVtkImages[0]->GetScalarSize();
 165 }
 166 //--------------------------------------------------------------------
 167
 168 //--------------------------------------------------------------------
 169 std::vector<double> vvImage::GetSpacing()
 170 {
 171   std::vector<double> spacing;
 172   int dim = this->GetNumberOfDimensions();
 173   for (int i = 0; i < dim; i++) {
 174     if (i == 3)
 175       spacing.push_back(mTimeSpacing);
 176     else
 177       spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
 178   }
 179   return spacing;
 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 vtkSmartPointer<vtkImageData> vvImage::GetFirstVTKImageData()
 240 {
 241   return mVtkImages[0];
 242 }
 243 //--------------------------------------------------------------------
 244
 245 //--------------------------------------------------------------------
 246 bool vvImage::IsScalarTypeInteger()
 247 {
 248   assert(mVtkImages.size()> 0);
 249   int t = mVtkImages[0]->GetScalarType();
 250   return IsScalarTypeInteger(t);
 251 }
 252 //--------------------------------------------------------------------
 253
 254 //--------------------------------------------------------------------
 255 bool vvImage::IsScalarTypeInteger(int t)
 256 {
 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   } else {
 268     return false;
 269   }
 270 }
 271
 272 //--------------------------------------------------------------------
 273
 274 //--------------------------------------------------------------------
 275 vtkSmartPointer<vtkTransform> vvImage::GetTransform()
 276 {
 277   return mTransform;
 278 }
 279 //--------------------------------------------------------------------
 280
 281 //--------------------------------------------------------------------
 282 vtkSmartPointer<vtkGridTransform> vvImage::GetGridTransform()
 283 {
 284   return mGridTransform;
 285 }
 286 //--------------------------------------------------------------------
 287
 288 //--------------------------------------------------------------------
 289 void vvImage::UpdateReslice()
 290 {
 291   for (unsigned int i=0; i<mVtkImageReslice.size(); i++) {
 292     mVtkImageReslice[i]->Update();
 293   }
 294 }
 295 //--------------------------------------------------------------------
 296
 297
 298 //--------------------------------------------------------------------
 299 vtkImageData * CopyAndCastToFloatFrom(vtkImageData * input)
 300 {
 301   vtkSmartPointer<vtkImageData>  p = vtkSmartPointer<vtkImageData>::New();
 302   p->SetExtent(input->GetExtent ()); // Only first ! could not be 4D
 303   p->SetScalarTypeToFloat();
 304   p->AllocateScalars();
 305   p->CopyAndCastFrom(input, input->GetExtent());
 306   return p;
 307 }
 308 //--------------------------------------------------------------------
 309
 310
 311 #endif // VVIMAGE_CXX