Debug RTStruct conversion with empty struc

[clitk.git] / vv / vvBinaryImageOverlayActor.cxx

diff --git a/vv/vvBinaryImageOverlayActor.cxx b/vv/vvBinaryImageOverlayActor.cxx
index aa5cecc7609b374925a5d7274f41aa031307ec22..1c18def90c2216c5b2d24c7ef3a0834e2f917513 100644 (file)
--- a/vv/vvBinaryImageOverlayActor.cxx
+++ b/vv/vvBinaryImageOverlayActor.cxx
@@ -31,10 +31,11 @@
 #include <vtkProperty.h>
 #include <vtkImageMapToRGBA.h>
 #include <vtkLookupTable.h>
+#include <vtkImageMapper3D.h>
 
 //------------------------------------------------------------------------------
 vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
-{ cout << __func__ << endl;
+{ 
   mTSlice = -1;
   mSlice = 0;
   mColor.resize(3);
@@ -52,7 +53,7 @@ vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
 
 //------------------------------------------------------------------------------
 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
-{ cout << __func__ << endl;
+{ 
   mImageActorList.clear();
 }
 //------------------------------------------------------------------------------
@@ -60,7 +61,7 @@ vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::RemoveActors()
-{ cout << __func__ << endl;
+{ 
   for (unsigned int i = 0; i < mImageActorList.size(); i++) {
     if (mSlicer != 0) {
       if (mSlicer != NULL) {
@@ -78,7 +79,7 @@ void vvBinaryImageOverlayActor::RemoveActors()
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
-{ cout << __func__ << endl;
+{ 
   mColor[0] = r;
   mColor[1] = g;
   mColor[2] = b;
@@ -88,7 +89,7 @@ void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
-{ cout << __func__ << endl;
+{ 
   mSlicer = slicer;
 }
 //------------------------------------------------------------------------------
@@ -96,7 +97,7 @@ void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
-{ cout << __func__ << endl;
+{ 
   if (!mSlicer) {
     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
     exit(0);
@@ -109,15 +110,57 @@ void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
   // Create an actor for each time slice
   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
     // how many intensity ?
+    
+
+
+    if (!mFusionReslice) {
+      mFusionReslice = vtkSmartPointer<vtkImageReslice>::New();
+      mFusionReslice->SetInterpolationModeToLinear();
+      mFusionReslice->AutoCropOutputOn();
+      mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1);
+    }
+
+    mConcatenatedFusionTransform = vtkSmartPointer<vtkTransform>::New();
+    mConcatenatedFusionTransform->Identity();
+    if (!mImage->GetTransform().empty()){
+      mConcatenatedFusionTransform->Concatenate(mImage->GetTransform()[0]);
+    }
+    mConcatenatedFusionTransform->Concatenate(mSlicer->GetSlicingTransform());
+    mFusionReslice->SetResliceAxes(mConcatenatedFusionTransform->GetMatrix());
+    if (mImage->IsTimeSequence()) {
+#if VTK_MAJOR_VERSION <= 5
+    mFusionReslice->SetInput(0, mImage->GetVTKImages()[numImage]);
+    mFusionReslice->UpdateInformation();
+#else
+    mFusionReslice->SetInputData(0, mImage->GetVTKImages()[numImage]);
+#endif
+    } else {
+#if VTK_MAJOR_VERSION <= 5
+    mFusionReslice->SetInput(0, mImage->GetVTKImages()[0]);
+    mFusionReslice->UpdateInformation();
+#else
+    mFusionReslice->SetInputData(0, mImage->GetVTKImages()[0]);
+#endif
+    }
+    mFusionReslice->Update();
+
+
+    
     vtkSmartPointer<vtkImageMapToRGBA> mOverlayMapper = vtkSmartPointer<vtkImageMapToRGBA>::New();
 #if VTK_MAJOR_VERSION <= 5
-    mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
+    mOverlayMapper->SetInput(mFusionReslice->GetOutput());
 #else
-    mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
+    mOverlayMapper->SetInputConnection(mFusionReslice->GetOutputPort(0));
 #endif
 
     double range[2];
-    mImage->GetVTKImages()[0]->GetScalarRange(range);
+    if (mImage->IsTimeSequence())
+    {
+        mImage->GetVTKImages()[numImage]->GetScalarRange(range);
+    }
+    else {
+        mImage->GetVTKImages()[0]->GetScalarRange(range);
+    }
     int n = range[1]-range[0]+1;
     mColorLUT->SetRange(range[0],range[1]);
     mColorLUT->SetNumberOfTableValues(n);
@@ -143,7 +186,7 @@ void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
 #if VTK_MAJOR_VERSION <= 5
     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 #else
-    mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
+    mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
 #endif
     mOverlayActor->SetPickable(0);
     mOverlayActor->SetVisibility(IsVisible);
@@ -155,7 +198,7 @@ void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
 
     mMapperList.push_back(mOverlayMapper);
     mImageActorList.push_back(mOverlayActor);
-    mSlicer->GetRenderer()->AddActor(mOverlayActor);
+    mSlicer->GetRenderer()->AddActor(mImageActorList[numImage]);
   }
 }
 //------------------------------------------------------------------------------
@@ -163,7 +206,7 @@ void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::SetOpacity(double d)
-{ cout << __func__ << endl;
+{ 
   mAlpha = d;
 }
 //------------------------------------------------------------------------------
@@ -205,7 +248,7 @@ void vvBinaryImageOverlayActor::SetOpacity(double d)
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
-{ cout << __func__ << endl;
+{ 
   mImage = image;
   if (modeBG) {
     mBackgroundValue = bg;
@@ -221,7 +264,7 @@ void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::HideActors()
-{ cout << __func__ << endl;
+{ 
   if (!mSlicer) return;
   mSlice = mSlicer->GetSlice();
   for(unsigned int i=0; i<mImageActorList.size(); i++) {
@@ -235,14 +278,12 @@ void vvBinaryImageOverlayActor::HideActors()
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::ShowActors()
-{ cout << __func__ << endl;
+{ 
   if (!mSlicer) return;
   mSlice = mSlicer->GetSlice();
   mTSlice = mSlicer->GetTSlice();
-  //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
   mImageActorList[mTSlice]->VisibilityOn();
   UpdateSlice(0, mSlice);
-  //}
   // Caller MUST call Render
   //mSlicer->Render();
 }
@@ -251,7 +292,7 @@ void vvBinaryImageOverlayActor::ShowActors()
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::UpdateColor()
-{ cout << __func__ << endl;
+{ 
   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
     // how many intensity ?
@@ -270,7 +311,7 @@ void vvBinaryImageOverlayActor::UpdateColor()
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
-{ cout << __func__ << endl;
+{ 
   if (!mSlicer) return;
 
   if (!force) {
@@ -290,13 +331,14 @@ void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
   int orientation = mSlicer->GetOrientation();
   int maskExtent[6];
   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
-  ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
+  ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetVTKImages()[mTSlice], mImage->GetVTKImages()[mTSlice]);
 #if VTK_MAJOR_VERSION <= 5
   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
 #else
   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
 #endif
-mSlicer->Print(cout);
+  HideActors();
+  mImageActorList[mTSlice]->VisibilityOn();
   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
 
   // set previous slice
@@ -311,7 +353,7 @@ void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
                                              int slice,
                                              int * inExtent,
                                              int * outExtent)
-{ cout << __func__ << endl;
+{ 
   switch (orientation) {
   case vtkImageViewer2::SLICE_ORIENTATION_XY:
     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
@@ -333,7 +375,7 @@ void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 
 //----------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
-{ cout << __func__ << endl;
+{ 
   for(int i=0; i<3; i++) {
     double a = (image->GetOrigin()[i] + inExtent[i*2]*image->GetSpacing()[i] - 
                 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
@@ -361,7 +403,7 @@ void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientatio
                                                                  int * extent,
                                                                  vtkImageActor * actor,
                                                                  double position)
-{ cout << __func__ << endl;
+{ 
   /* FIXME
      Error according to camera orientation
    */