- new GF system

[clitk.git] / common / vvImage.cxx

diff --git a/common/vvImage.cxx b/common/vvImage.cxx
index 7d68a1438e70e4656a430d153ec0145b247225d2..ae5c5a645ca5c842524be2c8b03c617485254571 100644 (file)
--- a/common/vvImage.cxx
+++ b/common/vvImage.cxx
@@ -1,7 +1,7 @@
 #ifndef VVIMAGE_CXX
 #define VVIMAGE_CXX
 
-/*=========================================================================
+/*-------------------------------------------------------------------------
 
 Program:   vv
 Language:  C++
@@ -23,29 +23,29 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-=========================================================================*/
+-------------------------------------------------------------------------*/
 
 #include "vvImage.h"
 #include "vtkImageData.h"
 #include "clitkCommon.h"
 #include <cassert>
 
-//====================================================================
+//--------------------------------------------------------------------
 vvImage::vvImage() {
     mVtkImages.resize(0);
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 vvImage::~vvImage() {
     for (unsigned int i = 0; i < mVtkImages.size(); i++) {
         if (mVtkImages[i] != NULL)
             mVtkImages[i]->Delete();
     }
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 void vvImage::SetImage(std::vector<vtkImageData*> images) {
     for (unsigned int i = 0; i < mVtkImages.size(); i++) {
         if (mVtkImages[i] != NULL)
@@ -56,15 +56,15 @@ void vvImage::SetImage(std::vector<vtkImageData*> images) {
         mVtkImages.push_back(images[i]);
     }
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 void vvImage::AddImage(vtkImageData* image) {
     mVtkImages.push_back(image);
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 void vvImage::Init() {
     for (unsigned int i = 0; i < mVtkImages.size(); i++) {
         if (mVtkImages[i] != NULL)
@@ -72,9 +72,9 @@ void vvImage::Init() {
     }
     mVtkImages.resize(0);
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 int vvImage::GetNumberOfSpatialDimensions() {
     int dim=GetNumberOfDimensions();
     if (IsTimeSequence())
@@ -82,9 +82,9 @@ int vvImage::GetNumberOfSpatialDimensions() {
     else
         return dim;
 }
-//====================================================================
+//--------------------------------------------------------------------
 //
-//====================================================================
+//--------------------------------------------------------------------
 int vvImage::GetNumberOfDimensions() const {
     if (mVtkImages.size())
     {
@@ -99,7 +99,7 @@ int vvImage::GetNumberOfDimensions() const {
     }
     return 0;
 }
-//====================================================================
+//--------------------------------------------------------------------
 void vvImage::GetScalarRange(double* range)
 {
     assert(mVtkImages.size());
@@ -113,25 +113,25 @@ void vvImage::GetScalarRange(double* range)
     }
 }
 
-//====================================================================
+//--------------------------------------------------------------------
 std::string vvImage::GetScalarTypeAsString() {
     return mVtkImages[0]->GetScalarTypeAsString();
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 int vvImage::GetNumberOfScalarComponents() {
     return mVtkImages[0]->GetNumberOfScalarComponents();
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 int vvImage::GetScalarSize() {
     return mVtkImages[0]->GetScalarSize();
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 std::vector<double> vvImage::GetSpacing() {
     std::vector<double> spacing;
     int dim = this->GetNumberOfDimensions();
@@ -144,9 +144,9 @@ std::vector<double> vvImage::GetSpacing() {
     }
     return spacing;
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 std::vector<double> vvImage::GetOrigin() const {
     std::vector<double> origin;
     int dim = this->GetNumberOfDimensions();
@@ -159,9 +159,9 @@ std::vector<double> vvImage::GetOrigin() const {
     }
     return origin;
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 std::vector<int> vvImage::GetSize() {
     std::vector<int> size0;
     int dim = this->GetNumberOfDimensions();
@@ -174,9 +174,9 @@ std::vector<int> vvImage::GetSize() {
     }
     return size0;
 }
-//====================================================================
+//--------------------------------------------------------------------
 
-//====================================================================
+//--------------------------------------------------------------------
 unsigned long vvImage::GetActualMemorySize() {
     unsigned long size = 0;
     for (unsigned int i = 0; i < mVtkImages.size(); i++) {
@@ -184,6 +184,56 @@ unsigned long vvImage::GetActualMemorySize() {
     }
     return size;
 }
-//====================================================================
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+bool vvImage::IsTimeSequence() {
+  return mVtkImages.size()>1;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+const std::vector<vtkImageData*>& vvImage::GetVTKImages() {
+  return mVtkImages;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+vtkImageData* vvImage::GetFirstVTKImageData() { 
+  return mVtkImages[0]; 
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+bool vvImage::IsScalarTypeInteger() {
+  assert(mVtkImages.size()> 0);
+  int t = mVtkImages[0]->GetScalarType();
+  return IsScalarTypeInteger(t);
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+bool vvImage::IsScalarTypeInteger(int t) {
+  if ((t == VTK_BIT) ||
+      (t == VTK_CHAR) ||
+      (t == VTK_UNSIGNED_CHAR) ||
+      (t == VTK_SHORT) ||
+      (t == VTK_UNSIGNED_SHORT) ||
+      (t == VTK_INT) ||
+      (t == VTK_UNSIGNED_INT) ||
+      (t == VTK_LONG) ||
+      (t == VTK_UNSIGNED_LONG))    {
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+//--------------------------------------------------------------------
+
 
 #endif // VVIMAGE_CXX