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