common/vvImage.cxx

   1 #ifndef VVIMAGE_CXX
   2 #define VVIMAGE_CXX
   3 #include "vvImage.h"
   4 #include "vtkImageData.h"
   5 #include "clitkCommon.h"
   6 #include <cassert>
   7
   8 //--------------------------------------------------------------------
   9 vvImage::vvImage() {
  10   mVtkImages.resize(0);
  11 }
  12 //--------------------------------------------------------------------
  13
  14
  15 //--------------------------------------------------------------------
  16 vvImage::~vvImage() {
  17   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
  18     if (mVtkImages[i] != NULL)
  19       mVtkImages[i]->Delete();
  20   }
  21 }
  22 //--------------------------------------------------------------------
  23
  24
  25 //--------------------------------------------------------------------
  26 void vvImage::SetImage(std::vector<vtkImageData*> images) {
  27   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
  28     if (mVtkImages[i] != NULL)
  29       mVtkImages[i]->Delete();
  30   }
  31   mVtkImages.resize(0);
  32   for (unsigned int i = 0; i < images.size(); i++) {
  33     mVtkImages.push_back(images[i]);
  34   }
  35 }
  36 //--------------------------------------------------------------------
  37
  38 //--------------------------------------------------------------------
  39 void vvImage::AddImage(vtkImageData* image) {
  40   mVtkImages.push_back(image);
  41 }
  42 //--------------------------------------------------------------------
  43
  44 //--------------------------------------------------------------------
  45 void vvImage::Init() {
  46   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
  47     if (mVtkImages[i] != NULL)
  48       mVtkImages[i]->Delete();
  49   }
  50   mVtkImages.resize(0);
  51 }
  52 //--------------------------------------------------------------------
  53
  54
  55 //--------------------------------------------------------------------
  56 int vvImage::GetNumberOfSpatialDimensions() {
  57   int dim=GetNumberOfDimensions();
  58   if (IsTimeSequence())
  59     return dim-1;
  60   else
  61     return dim;
  62 }
  63 //--------------------------------------------------------------------
  64
  65
  66 //--------------------------------------------------------------------
  67 int vvImage::GetNumberOfDimensions() const {
  68   if (mVtkImages.size())
  69     {
  70       int dimension = 2;
  71       int extent[6];
  72       mVtkImages[0]->GetWholeExtent(extent);
  73       if (extent[5] - extent[4] >= 1)
  74         dimension++;
  75       if (mVtkImages.size() > 1)
  76         dimension++;
  77       return dimension;
  78     }
  79   return 0;
  80 }
  81 //--------------------------------------------------------------------
  82
  83
  84 //--------------------------------------------------------------------
  85 void vvImage::GetScalarRange(double* range)
  86 {
  87   assert(mVtkImages.size());
  88   double * temp = mVtkImages[0]->GetScalarRange();
  89   range[0]=temp[0];range[1]=temp[1];
  90   for (unsigned int i=1;i<mVtkImages.size();i++)
  91     {
  92       temp = mVtkImages[i]->GetScalarRange();
  93       if (temp[0] < range[0]) range[0]=temp[0];
  94       if (temp[1] > range[1]) range[1]=temp[1];
  95     }
  96 }
  97 //--------------------------------------------------------------------
  98
  99
 100 //--------------------------------------------------------------------
 101 std::string vvImage::GetScalarTypeAsString() {
 102   // WARNING VTK pixel type different from ITK Pixel type
 103   std::string vtktype = mVtkImages[0]->GetScalarTypeAsString();
 104   if (vtktype == "unsigned char") return "unsigned_char";
 105   if (vtktype == "unsigned short") return "unsigned_short";
 106   if (vtktype == "unsigned int") return "unsigned_int";
 107   return vtktype;
 108 }
 109 //--------------------------------------------------------------------
 110
 111
 112 //--------------------------------------------------------------------
 113 int vvImage::GetNumberOfScalarComponents() {
 114   return mVtkImages[0]->GetNumberOfScalarComponents();
 115 }
 116 //--------------------------------------------------------------------
 117
 118
 119 //--------------------------------------------------------------------
 120 int vvImage::GetScalarSize() {
 121   return mVtkImages[0]->GetScalarSize();
 122 }
 123 //--------------------------------------------------------------------
 124
 125
 126 //--------------------------------------------------------------------
 127 std::vector<double> vvImage::GetSpacing() {
 128   std::vector<double> spacing;
 129   int dim = this->GetNumberOfDimensions();
 130   for (int i = 0; i < dim; i++)
 131     {
 132       if (i == 3)
 133         spacing.push_back(1);
 134       else
 135         spacing.push_back(mVtkImages[0]->GetSpacing()[i]);
 136     }
 137   return spacing;
 138 }
 139 //--------------------------------------------------------------------
 140
 141
 142 //--------------------------------------------------------------------
 143 std::vector<double> vvImage::GetOrigin() const {
 144   std::vector<double> origin;
 145   int dim = this->GetNumberOfDimensions();
 146   for (int i = 0; i < dim; i++)
 147     {
 148       if (i == 3)
 149         origin.push_back(0);
 150       else
 151         origin.push_back(mVtkImages[0]->GetOrigin()[i]);
 152     }
 153   return origin;
 154 }
 155 //--------------------------------------------------------------------
 156
 157
 158 //--------------------------------------------------------------------
 159 std::vector<int> vvImage::GetSize() {
 160   std::vector<int> size0;
 161   int dim = this->GetNumberOfDimensions();
 162   for (int i = 0; i < dim; i++)
 163     {
 164       if (i == 3)
 165         size0.push_back(mVtkImages.size());
 166       else
 167         size0.push_back(mVtkImages[0]->GetDimensions()[i]);
 168     }
 169   return size0;
 170 }
 171 //--------------------------------------------------------------------
 172
 173
 174 //--------------------------------------------------------------------
 175 unsigned long vvImage::GetActualMemorySize() {
 176   unsigned long size = 0;
 177   for (unsigned int i = 0; i < mVtkImages.size(); i++) {
 178     size += mVtkImages[i]->GetActualMemorySize();
 179   }
 180   return size;
 181 }
 182 //--------------------------------------------------------------------
 183
 184
 185 //--------------------------------------------------------------------
 186 bool vvImage::IsTimeSequence() {
 187   return mVtkImages.size()>1;
 188 }
 189 //--------------------------------------------------------------------
 190
 191
 192 //--------------------------------------------------------------------
 193 const std::vector<vtkImageData*>& vvImage::GetVTKImages() {
 194   return mVtkImages;
 195 }
 196 //--------------------------------------------------------------------
 197
 198
 199 //--------------------------------------------------------------------
 200 vtkImageData* vvImage::GetFirstVTKImageData() {
 201   return mVtkImages[0];
 202 }
 203 //--------------------------------------------------------------------
 204
 205
 206 //--------------------------------------------------------------------
 207 bool vvImage::IsScalarTypeInteger() {
 208   assert(mVtkImages.size()> 0);
 209   int t = mVtkImages[0]->GetScalarType();
 210   return IsScalarTypeInteger(t);
 211 }
 212 //--------------------------------------------------------------------
 213
 214
 215 //--------------------------------------------------------------------
 216 bool vvImage::IsScalarTypeInteger(int t) {
 217   if ((t == VTK_BIT) ||
 218       (t == VTK_CHAR) ||
 219       (t == VTK_UNSIGNED_CHAR) ||
 220       (t == VTK_SHORT) ||
 221       (t == VTK_UNSIGNED_SHORT) ||
 222       (t == VTK_INT) ||
 223       (t == VTK_UNSIGNED_INT) ||
 224       (t == VTK_LONG) ||
 225       (t == VTK_UNSIGNED_LONG))    {
 226     return true;
 227   }
 228   else {
 229     return false;
 230   }
 231 }
 232 //--------------------------------------------------------------------
 233
 234
 235 #endif // VVIMAGE_CXX