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   Init();
  30 }
  31 //--------------------------------------------------------------------
  32
  33
  34 //--------------------------------------------------------------------
  35 void vvImage::Init() {
  36     mTimeSpacing = 1;
  37     mTimeOrigin = 0;
  38
  39     if (CLITK_EXPERIMENTAL)
  40     {
  41         mVtkImageReslice = vtkSmartPointer<vtkImageReslice>::New();
  42         transform = vtkSmartPointer<vtkTransform>::New();
  43         mVtkImageReslice->SetInterpolationModeToLinear();
  44         mVtkImageReslice->AutoCropOutputOn();
  45         mVtkImageReslice->SetBackgroundColor(-1000,-1000,-1000,1);
  46         mVtkImageReslice->SetResliceTransform(transform);
  47     }
  48 }
  49 //--------------------------------------------------------------------
  50
  51 //--------------------------------------------------------------------
  52 vvImage::~vvImage() {
  53     Reset();
  54 }
  55 //--------------------------------------------------------------------
  56
  57 //--------------------------------------------------------------------
  58 void vvImage::Reset() {
  59     if (CLITK_EXPERIMENTAL)
  60     {
  61         for (unsigned int i = 0; i < mVtkImages.size(); i++)
  62             mVtkImages[i] = (vtkImageData*)mVtkImageReslice->GetInput(i);
  63         mVtkImageReslice->RemoveAllInputs();
  64     }
  65     for (unsigned int i = 0; i < mVtkImages.size(); i++)
  66         mVtkImages[i]->Delete();
  67     mVtkImages.resize(0);
  68     Init();
  69 }
  70 //--------------------------------------------------------------------
  71
  72
  73 //--------------------------------------------------------------------
  74 void vvImage::SetImage(std::vector< vtkImageData* > images) {
  75     Reset();
  76     for (unsigned int i = 0; i < images.size(); i++)
  77         AddImage(images[i]);
  78 }
  79 //--------------------------------------------------------------------
  80
  81
  82 //--------------------------------------------------------------------
  83 void vvImage::AddImage(vtkImageData* image) {
  84     if (CLITK_EXPERIMENTAL)
  85     {
  86         mVtkImageReslice->SetInput(mVtkImages.size(), image);
  87         mVtkImageReslice->Update();
  88         mVtkImages.push_back( mVtkImageReslice->GetOutput( mVtkImages.size() ) );
  89     }
  90     else
  91         mVtkImages.push_back(image);
  92 }
  93 //--------------------------------------------------------------------
  94
  95 //--------------------------------------------------------------------
  96 int vvImage::GetNumberOfSpatialDimensions() {
  97     int dim=GetNumberOfDimensions();
  98     if (IsTimeSequence())
  99         return dim-1;
 100     else
 101         return dim;
 102 }
 103 //--------------------------------------------------------------------
 104 //
 105 //--------------------------------------------------------------------
 106 int vvImage::GetNumberOfDimensions() const {
 107     if (mVtkImages.size())
 108     {
 109         int dimension = 2;
 110         int extent[6];
 111         mVtkImages[0]->GetWholeExtent(extent);
 112         if (extent[5] - extent[4] >= 1)
 113             dimension++;
 114         if (mVtkImages.size() > 1)
 115             dimension++;
 116         return dimension;
 117     }
 118     return 0;
 119 }
 120 //--------------------------------------------------------------------
 121 void vvImage::GetScalarRange(double* range)
 122 {
 123     assert(mVtkImages.size());
 124     double * temp = mVtkImages[0]->GetScalarRange();
 125     range[0]=temp[0];range[1]=temp[1];
 126     for (unsigned int i=1;i<mVtkImages.size();i++)
 127     {
 128         temp = mVtkImages[i]->GetScalarRange();
 129         if (temp[0] < range[0]) range[0]=temp[0];
 130         if (temp[1] > range[1]) range[1]=temp[1];
 131     }
 132 }
 133
 134 //--------------------------------------------------------------------
 135 std::string vvImage::GetScalarTypeAsString() {
 136     return mVtkImages[0]->GetScalarTypeAsString();
 137 }
 138 //--------------------------------------------------------------------
 139
 140 //--------------------------------------------------------------------
 141 int vvImage::GetNumberOfScalarComponents() {
 142     return mVtkImages[0]->GetNumberOfScalarComponents();
 143 }
 144 //--------------------------------------------------------------------
 145
 146 //--------------------------------------------------------------------
 147 int vvImage::GetScalarSize() {
 148     return mVtkImages[0]->GetScalarSize();
 149 }
 150 //--------------------------------------------------------------------
 151
 152 //--------------------------------------------------------------------
 153 std::vector<double> vvImage::GetSpacing() {
 154     std::vector<double> spacing;
 155     int dim = this->GetNumberOfDimensions();
 156     for (int i = 0; i < dim; i++)
 157     {
 158         if (i == 3)
 159             spacing.push_back(1);
 160         else
 161             spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
 162       if (i == 3)
 163         spacing.push_back(mTimeSpacing);
 164       else
 165         spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
 166     }
 167     return spacing;
 168 }
 169 //--------------------------------------------------------------------
 170
 171 //--------------------------------------------------------------------
 172 std::vector<double> vvImage::GetOrigin() const {
 173     std::vector<double> origin;
 174     int dim = this->GetNumberOfDimensions();
 175     for (int i = 0; i < dim; i++)
 176     {
 177         if (i == 3)
 178             origin.push_back(0);
 179         else
 180             origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 181       if (i == 3)
 182         origin.push_back(mTimeOrigin);
 183       else
 184         origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 185     }
 186     return origin;
 187 }
 188 //--------------------------------------------------------------------
 189
 190 //--------------------------------------------------------------------
 191 std::vector<int> vvImage::GetSize() {
 192     std::vector<int> size0;
 193     int dim = this->GetNumberOfDimensions();
 194     for (int i = 0; i < dim; i++)
 195     {
 196         if (i == 3)
 197             size0.push_back(mVtkImages.size());
 198         else
 199             size0.push_back(mVtkImages[0]->GetDimensions()[i]);
 200     }
 201     return size0;
 202 }
 203 //--------------------------------------------------------------------
 204
 205 //--------------------------------------------------------------------
 206 unsigned long vvImage::GetActualMemorySize() {
 207     unsigned long size = 0;
 208     for (unsigned int i = 0; i < mVtkImages.size(); i++) {
 209         size += mVtkImages[i]->GetActualMemorySize();
 210     }
 211     return size;
 212 }
 213 //--------------------------------------------------------------------
 214
 215
 216 //--------------------------------------------------------------------
 217 bool vvImage::IsTimeSequence() {
 218   return mVtkImages.size()>1;
 219 }
 220 //--------------------------------------------------------------------
 221
 222
 223 //--------------------------------------------------------------------
 224 const std::vector<vtkImageData*>& vvImage::GetVTKImages() {
 225   return mVtkImages;
 226 }
 227 //--------------------------------------------------------------------
 228
 229
 230 //--------------------------------------------------------------------
 231 vtkImageData* vvImage::GetFirstVTKImageData() {
 232   return mVtkImages[0];
 233 }
 234 //--------------------------------------------------------------------
 235
 236
 237 //--------------------------------------------------------------------
 238 bool vvImage::IsScalarTypeInteger() {
 239   assert(mVtkImages.size()> 0);
 240   int t = mVtkImages[0]->GetScalarType();
 241   return IsScalarTypeInteger(t);
 242 }
 243 //--------------------------------------------------------------------
 244
 245 //--------------------------------------------------------------------
 246 bool vvImage::IsScalarTypeInteger(int t) {
 247   if ((t == VTK_BIT) ||
 248       (t == VTK_CHAR) ||
 249       (t == VTK_UNSIGNED_CHAR) ||
 250       (t == VTK_SHORT) ||
 251       (t == VTK_UNSIGNED_SHORT) ||
 252       (t == VTK_INT) ||
 253       (t == VTK_UNSIGNED_INT) ||
 254       (t == VTK_LONG) ||
 255       (t == VTK_UNSIGNED_LONG))    {
 256     return true;
 257   }
 258   else {
 259     return false;
 260   }
 261 }
 262
 263 //--------------------------------------------------------------------
 264
 265 //--------------------------------------------------------------------
 266
 267 void vvImage::SetVTKImageReslice(vtkImageReslice* reslice) {
 268    mVtkImageReslice=reslice;
 269
 270 }
 271 //--------------------------------------------------------------------
 272
 273 //--------------------------------------------------------------------
 274 vtkAbstractTransform * vvImage::GetTransform()
 275 {
 276     return mVtkImageReslice->GetResliceTransform();
 277 }
 278 //--------------------------------------------------------------------
 279
 280 //-------------------------------------------------------------------
 281 void vvImage::SetRotateX(int xvalue)
 282 {
 283     transform->PostMultiply();
 284     transform->Translate(-origin[0],-origin[1],-origin[2]);
 285     transform->RotateX(xvalue);
 286     transform->Translate(origin[0],origin[1],origin[2]);
 287      mVtkImageReslice->Update();
 288 }
 289
 290 //--------------------------------------------------------------------
 291
 292 //-------------------------------------------------------------------
 293 void vvImage::SetRotateY(int yvalue)
 294 {
 295     transform->PostMultiply();
 296     transform->Translate(-origin[0],-origin[1],-origin[2]);
 297     transform->RotateY(yvalue);
 298     transform->Translate(origin[0],origin[1],origin[2]);
 299      mVtkImageReslice->Update();
 300 }
 301 //--------------------------------------------------------------------
 302
 303 //-------------------------------------------------------------------
 304 void vvImage::SetRotateZ(int zvalue)
 305 {
 306     transform->PostMultiply();
 307     transform->Translate(-origin[0],-origin[1],-origin[2]);
 308     transform->RotateZ(zvalue);
 309     transform->Translate(origin[0],origin[1],origin[2]);
 310      mVtkImageReslice->Update();
 311 }
 312 //--------------------------------------------------------------------
 313
 314 //-------------------------------------------------------------------
 315 void vvImage::SetTranslationX(int xvalue)
 316 {
 317     transform->Translate(xvalue,0,0);
 318      mVtkImageReslice->Update();
 319 }
 320 //--------------------------------------------------------------------
 321
 322 //-------------------------------------------------------------------
 323
 324 void vvImage::SetTranslationY(int yvalue)
 325 {
 326     transform->Translate(0,yvalue,0);
 327      mVtkImageReslice->Update();
 328 }
 329 //--------------------------------------------------------------------
 330
 331 //-------------------------------------------------------------------
 332 void vvImage::SetTranslationZ(int zvalue)
 333 {
 334     transform->Translate(0,0,zvalue);
 335      mVtkImageReslice->Update();
 336 }
 337 //-------------------------------------------------------------------
 338
 339 //-------------------------------------------------------------------
 340 void vvImage::SetOrigin(double value[3])
 341 {
 342   origin=new double[mVtkImageReslice->GetOutputDimensionality()];
 343   origin[0]=value[0];
 344   origin[1]=value[1];
 345   origin[2]=value[2];
 346 }
 347
 348 //--------------------------------------------------------------------
 349 void vvImage::SetTransform(vtkAbstractTransform  *transform)
 350 {
 351   mVtkImageReslice->SetResliceTransform(transform);
 352   mVtkImageReslice->Update();
 353 }
 354 //--------------------------------------------------------------------
 355
 356 #endif // VVIMAGE_CXX