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