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
  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   mVtkImageReslice.push_back(vtkSmartPointer<vtkImageReslice>::New());
  85
  86   mVtkImageReslice.back()->SetInterpolationModeToLinear();
  87   mVtkImageReslice.back()->AutoCropOutputOn();
  88   mVtkImageReslice.back()->SetBackgroundColor(-1000,-1000,-1000,1);
  89   mVtkImageReslice.back()->SetResliceTransform(mGeneralTransform);
  90   mVtkImageReslice.back()->SetInput(0, image);
  91   mVtkImageReslice.back()->Update();
  92
  93   mVtkImages.push_back( mVtkImageReslice.back()->GetOutput(0) );
  94 }
  95 //--------------------------------------------------------------------
  96
  97 //--------------------------------------------------------------------
  98 int vvImage::GetNumberOfSpatialDimensions()
  99 {
 100   int dim=GetNumberOfDimensions();
 101   if (IsTimeSequence())
 102     return dim-1;
 103   else
 104     return dim;
 105 }
 106 //--------------------------------------------------------------------
 107
 108 //--------------------------------------------------------------------
 109 int vvImage::GetNumberOfDimensions() const
 110 {
 111   if (mVtkImages.size()) {
 112     int dimension = 2;
 113     int extent[6];
 114     mVtkImages[0]->GetWholeExtent(extent);
 115     if (extent[5] - extent[4] >= 1)
 116       dimension++;
 117     if (mVtkImages.size() > 1)
 118       dimension++;
 119     return dimension;
 120   }
 121   return 0;
 122 }
 123 //--------------------------------------------------------------------
 124
 125 //--------------------------------------------------------------------
 126 void vvImage::GetScalarRange(double* range)
 127 {
 128   assert(mVtkImages.size());
 129   double * temp = mVtkImages[0]->GetScalarRange();
 130   range[0]=temp[0];
 131   range[1]=temp[1];
 132   for (unsigned int i=1; i<mVtkImages.size(); i++) {
 133     temp = mVtkImages[i]->GetScalarRange();
 134     if (temp[0] < range[0]) range[0]=temp[0];
 135     if (temp[1] > range[1]) range[1]=temp[1];
 136   }
 137 }
 138 //--------------------------------------------------------------------
 139
 140 //--------------------------------------------------------------------
 141 std::string vvImage::GetScalarTypeAsITKString()
 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 std::vector<double> vvImage::GetOrigin() const
 181 {
 182   std::vector<double> origin;
 183   int dim = this->GetNumberOfDimensions();
 184   for (int i = 0; i < dim; i++) {
 185     if (i == 3)
 186       origin.push_back(mTimeOrigin);
 187     else
 188       origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 189   }
 190   return origin;
 191 }
 192 //--------------------------------------------------------------------
 193
 194 //--------------------------------------------------------------------
 195 std::vector<int> vvImage::GetSize()
 196 {
 197   std::vector<int> size0;
 198   int dim = this->GetNumberOfDimensions();
 199   for (int i = 0; i < dim; i++) {
 200     if (i == 3)
 201       size0.push_back(mVtkImages.size());
 202     else
 203       size0.push_back(mVtkImages[0]->GetDimensions()[i]);
 204   }
 205   return size0;
 206 }
 207 //--------------------------------------------------------------------
 208
 209 //--------------------------------------------------------------------
 210 unsigned long vvImage::GetActualMemorySize()
 211 {
 212   unsigned long size = 0;
 213   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
 214     size += mVtkImages[i]->GetActualMemorySize();
 215   }
 216   return size;
 217 }
 218 //--------------------------------------------------------------------
 219
 220
 221 //--------------------------------------------------------------------
 222 bool vvImage::IsTimeSequence()
 223 {
 224   return mVtkImages.size()>1;
 225 }
 226 //--------------------------------------------------------------------
 227
 228
 229 //--------------------------------------------------------------------
 230 const std::vector<vtkImageData*>& vvImage::GetVTKImages()
 231 {
 232   return mVtkImages;
 233 }
 234 //--------------------------------------------------------------------
 235
 236 //--------------------------------------------------------------------
 237 vtkSmartPointer<vtkImageData> vvImage::GetFirstVTKImageData()
 238 {
 239   return mVtkImages[0];
 240 }
 241 //--------------------------------------------------------------------
 242
 243 //--------------------------------------------------------------------
 244 bool vvImage::IsScalarTypeInteger()
 245 {
 246   assert(mVtkImages.size()> 0);
 247   int t = mVtkImages[0]->GetScalarType();
 248   return IsScalarTypeInteger(t);
 249 }
 250 //--------------------------------------------------------------------
 251
 252 //--------------------------------------------------------------------
 253 bool vvImage::IsScalarTypeInteger(int t)
 254 {
 255   if ((t == VTK_BIT) ||
 256       (t == VTK_CHAR) ||
 257       (t == VTK_UNSIGNED_CHAR) ||
 258       (t == VTK_SHORT) ||
 259       (t == VTK_UNSIGNED_SHORT) ||
 260       (t == VTK_INT) ||
 261       (t == VTK_UNSIGNED_INT) ||
 262       (t == VTK_LONG) ||
 263       (t == VTK_UNSIGNED_LONG))    {
 264     return true;
 265   } else {
 266     return false;
 267   }
 268 }
 269
 270 //--------------------------------------------------------------------
 271
 272 //--------------------------------------------------------------------
 273 vtkSmartPointer<vtkTransform> vvImage::GetTransform()
 274 {
 275   return mTransform;
 276 }
 277 //--------------------------------------------------------------------
 278
 279 //--------------------------------------------------------------------
 280 vtkSmartPointer<vtkGridTransform> vvImage::GetGridTransform()
 281 {
 282   return mGridTransform;
 283 }
 284 //--------------------------------------------------------------------
 285
 286 //--------------------------------------------------------------------
 287 void vvImage::UpdateReslice()
 288 {
 289   for (unsigned int i=0; i<mVtkImageReslice.size(); i++) {
 290     mVtkImageReslice[i]->Update();
 291   }
 292 }
 293 //--------------------------------------------------------------------
 294
 295
 296 //--------------------------------------------------------------------
 297 vtkImageData * CopyAndCastToFloatFrom(vtkImageData * input)
 298 {
 299   vtkSmartPointer<vtkImageData>  p = vtkSmartPointer<vtkImageData>::New();
 300   p->SetExtent(input->GetExtent ()); // Only first ! could not be 4D
 301   p->SetScalarTypeToFloat();
 302   p->AllocateScalars();
 303   p->CopyAndCastFrom(input, input->GetExtent());
 304   return p;
 305 }
 306 //--------------------------------------------------------------------
 307
 308
 309 #endif // VVIMAGE_CXX