Allow to display in all directions for images with size 2 and 3 in 3rd direction

[clitk.git] / vv / vvSlicer.cxx

diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx
index 2729bd68925da8f2332576302b50ef9f00c59b6f..2089d41caa3d564e5e076b0e3f94df4710d56fb5 100644 (file)
--- a/vv/vvSlicer.cxx
+++ b/vv/vvSlicer.cxx
@@ -24,6 +24,7 @@
 #include "vvSlicerManagerCommand.h"
 #include "vvGlyphSource.h"
 #include "vvGlyph2D.h"
+#include "vvUtils.h"
 
 #include <vtkVersion.h>
 #include <vtkExtentTranslator.h>
@@ -57,6 +58,7 @@
 #include <vtkLight.h>
 #include <vtkLightCollection.h>
 #include <vtkScalarBarActor.h>
+#include <vtkImageProperty.h>
 #include <vtkLookupTable.h>
 
 #include <vtkRenderer.h>
@@ -75,8 +77,8 @@
 #include <vtkAssignAttribute.h>
 #include <vtkImageAccumulate.h>
 #include <vtkImageReslice.h>
-#include <vtkOpenGLImageSliceMapper.h>
 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
+#  include <vtkOpenGLImageSliceMapper.h>
 #  include <vtkImageMapper3D.h>
 #  include <vtkImageSliceMapper.h>
 #endif
@@ -133,7 +135,7 @@ vvSlicer::vvSlicer()
 
   pdmA = vtkSmartPointer<vtkActor2D>::New();
   pdmA->SetMapper(pdm);
-  pdmA->GetProperty()->SetColor(255,10,212);
+  pdmA->GetProperty()->SetColor(1,0,0);
   pdmA->SetVisibility(0);
   pdmA->SetPickable(0);
 
@@ -149,10 +151,10 @@ vvSlicer::vvSlicer()
 
   legend = vtkSmartPointer<vtkScalarBarActor>::New();
   //legend->SetTitle("test!");
-  legend->SetPosition(0.82,0.18);
-  legend->SetWidth(0.1);
+  legend->SetPosition(0.82,0.08);
+  //legend->SetWidth(0.1);
   legend->SetVisibility(0);
-  legend->SetLabelFormat("%.1f");
+  legend->SetLabelFormat("%.1e");
   this->GetRenderer()->AddActor(legend);
   showFusionLegend = false;
 
@@ -169,6 +171,7 @@ vvSlicer::vvSlicer()
   mConcatenatedTransform = vtkSmartPointer<vtkTransform>::New();
   mConcatenatedFusionTransform = vtkSmartPointer<vtkTransform>::New();
   mConcatenatedOverlayTransform = vtkSmartPointer<vtkTransform>::New();
+  mConcatenatedVFTransform = vtkSmartPointer<vtkTransform>::New();
   mFirstSetSliceOrientation = true;
 }
 //------------------------------------------------------------------------------
@@ -266,7 +269,7 @@ void vvSlicer::ToggleContourSuperposition()
 
 
 //------------------------------------------------------------------------------
-void vvSlicer::SetCursorColor(int r,int g, int b)
+void vvSlicer::SetCursorColor(double r, double g, double b)
 { 
   pdmA->GetProperty()->SetColor(r,g,b);
 }
@@ -322,6 +325,13 @@ double* vvSlicer::GetCurrentPosition()
 }
 //------------------------------------------------------------------------------
 
+//------------------------------------------------------------------------------
+void vvSlicer::SetInterpolationImageReslice(int interpolation)
+{ 
+  mImageReslice->SetInterpolationMode(interpolation);
+}
+//------------------------------------------------------------------------------
+
 //------------------------------------------------------------------------------
 void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
 { 
@@ -343,6 +353,8 @@ void vvSlicer::SetImage(vvImage::Pointer image)
     if (!mImageReslice) {
       mImageReslice = vtkSmartPointer<vtkImageReslice>::New();
       mImageReslice->SetInterpolationModeToLinear();
+      SetInterpolationImageReslice(getInterpolationFavoriteStatus());
+      GetImageActor()->SetInterpolate(getInterpolationFavoriteStatus());
       mImageReslice->AutoCropOutputOn();
       mImageReslice->SetBackgroundColor(-1000,-1000,-1000,1);
     }
@@ -350,7 +362,7 @@ void vvSlicer::SetImage(vvImage::Pointer image)
     mConcatenatedTransform->Identity();
     mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
     mConcatenatedTransform->Concatenate(mSlicingTransform);
-    mImageReslice->SetResliceTransform(mConcatenatedTransform);
+    mImageReslice->SetResliceAxes(mConcatenatedTransform->GetMatrix());
 #if VTK_MAJOR_VERSION <= 5
     mImageReslice->SetInput(0, mImage->GetFirstVTKImageData());
 #else
@@ -368,8 +380,7 @@ void vvSlicer::SetImage(vvImage::Pointer image)
 #if VTK_MAJOR_VERSION <= 5
     this->GetInput()->GetWholeExtent(extent);
 #else
-    int* ext = mImageReslice->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT());
-    copyExtent(ext, extent);
+    mImageReslice->GetOutput()->GetExtent(extent);
 #endif
 
     // Prevent crash when reload -> change slice if outside extent
@@ -383,8 +394,11 @@ void vvSlicer::SetImage(vvImage::Pointer image)
 #if VTK_MAJOR_VERSION <= 5
     mImageReslice->GetOutput()->SetUpdateExtent(extent);
     mImageReslice->GetOutput()->Update();
+#elif VTK_MAJOR_VERSION >= 8 || (VTK_MAJOR_VERSION == 7 && VTK_MINOR_VERSION >= 1)
+    mImageReslice->UpdateExtent(extent);
+    mImageReslice->Update();
 #else
-    //mImageReslice->SetUpdateExtent(extent);
+    mImageReslice->SetUpdateExtent(extent);
     mImageReslice->Update();
 #endif
 
@@ -414,9 +428,10 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay)
     mConcatenatedOverlayTransform->Identity();
     mConcatenatedOverlayTransform->Concatenate(mOverlay->GetTransform()[0]);
     mConcatenatedOverlayTransform->Concatenate(mSlicingTransform);
-    mOverlayReslice->SetResliceTransform(mConcatenatedOverlayTransform);
+    mOverlayReslice->SetResliceAxes(mConcatenatedOverlayTransform->GetMatrix());
 #if VTK_MAJOR_VERSION <= 5
     mOverlayReslice->SetInput(0, mOverlay->GetFirstVTKImageData());
+    mImageReslice->UpdateInformation();
 #else
     mOverlayReslice->SetInputData(0, mOverlay->GetFirstVTKImageData());
 #endif
@@ -443,6 +458,7 @@ void vvSlicer::SetOverlay(vvImage::Pointer overlay)
 #if VTK_MAJOR_VERSION >= 6 || (VTK_MAJOR_VERSION >= 5 && VTK_MINOR_VERSION >= 10)
       mOverlayActor->GetMapper()->BorderOn();
 #endif
+      mOverlayActor->SetInterpolate(getInterpolationFavoriteStatus());
       }
 
     //stupid but necessary : the Overlay need to be rendered before fusion
@@ -480,9 +496,10 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
     mConcatenatedFusionTransform->Identity();
     mConcatenatedFusionTransform->Concatenate(mFusion->GetTransform()[0]);
     mConcatenatedFusionTransform->Concatenate(mSlicingTransform);
-    mFusionReslice->SetResliceTransform(mConcatenatedFusionTransform);
+    mFusionReslice->SetResliceAxes(mConcatenatedFusionTransform->GetMatrix());
 #if VTK_MAJOR_VERSION <= 5
     mFusionReslice->SetInput(0, mFusion->GetFirstVTKImageData());
+    mFusionReslice->UpdateInformation();
 #else
     mFusionReslice->SetInputData(0, mFusion->GetFirstVTKImageData());
 #endif
@@ -517,6 +534,7 @@ void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
       mFusionActor->GetMapper()->BorderOn();
 #endif
 
+      mFusionActor->SetInterpolate(getInterpolationFavoriteStatus());
       this->GetRenderer()->AddActor(mFusionActor);
     }
 
@@ -572,15 +590,31 @@ void vvSlicer::SetVF(vvImage::Pointer vf)
     mVFVisibility = true;
 
     if (!mAAFilter) {
+      mVFReslice = vtkSmartPointer<vtkImageReslice>::New();
+      mVFReslice->SetInterpolationModeToLinear();
+      mVFReslice->AutoCropOutputOn();
+      mVFReslice->SetBackgroundColor(-1000,-1000,-1000,1);
       mAAFilter= vtkSmartPointer<vtkAssignAttribute>::New();
       mVOIFilter = vtkSmartPointer<vtkExtractVOI>::New();
       mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
     }
+
+    mConcatenatedVFTransform->Identity();
+    mConcatenatedVFTransform->Concatenate(mVF->GetTransform()[0]);
+    mConcatenatedVFTransform->Concatenate(mSlicingTransform);
+    mVFReslice->SetResliceAxes(mConcatenatedVFTransform->GetMatrix());
+#if VTK_MAJOR_VERSION <= 5
+    mVFReslice->SetInput(0, mVF->GetFirstVTKImageData());
+#else
+    mVFReslice->SetInputData(0, mVF->GetFirstVTKImageData());
+#endif
+    mVFReslice->Update();
+
 #if VTK_MAJOR_VERSION <= 5
-    mVOIFilter->SetInput(vf->GetFirstVTKImageData());
+    mVOIFilter->SetInput(mVFReslice->GetOutput());
     mAAFilter->SetInput(mVOIFilter->GetOutput());
 #else
-    mVOIFilter->SetInputData(vf->GetFirstVTKImageData());
+    mVOIFilter->SetInputConnection(mVFReslice->GetOutputPort());
     mAAFilter->SetInputConnection(mVOIFilter->GetOutputPort());
 #endif
     ///This tells VTK to use the scalar (pixel) data of the image to draw the little arrows
@@ -624,7 +658,9 @@ void vvSlicer::SetVF(vvImage::Pointer vf)
 #else
     mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
 #endif
+#ifndef VTK_OPENGL2
     mVFMapper->ImmediateModeRenderingOn();
+#endif
     mVFMapper->SetLookupTable(mVFColorLUT);
 
     if (!mVFActor)
@@ -669,12 +705,24 @@ void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
     mLandClipper->SetClipFunction(mClipBox);
     mLandClipper->InsideOutOn();
 #if VTK_MAJOR_VERSION <= 5
-    mLandClipper->SetInput(mLandmarks->GetOutput());
+    mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+    mLandmarkTransform->SetInput(mLandmarks->GetOutput());
+    mConcatenatedTransform->Identity();
+    mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+    mConcatenatedTransform->Concatenate(mSlicingTransform);
+    mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
+    mLandClipper->SetInput(mLandmarkTransform->GetOutput());
 
     mLandGlyph->SetSource(mCross->GetOutput());
     mLandGlyph->SetInput(mLandClipper->GetOutput());
 #else
-    mLandClipper->SetInputData(mLandmarks->GetOutput());
+    mLandmarkTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+    mLandmarkTransform->SetInputData(mLandmarks->GetOutput());
+    mConcatenatedTransform->Identity();
+    mConcatenatedTransform->Concatenate(mImage->GetTransform()[0]);
+    mConcatenatedTransform->Concatenate(mSlicingTransform);
+    mLandmarkTransform->SetTransform(mConcatenatedTransform->GetInverse());
+    mLandClipper->SetInputConnection(mLandmarkTransform->GetOutputPort());
 
     mLandGlyph->SetSourceConnection(mCross->GetOutputPort());
     mLandGlyph->SetInputConnection(mLandClipper->GetOutputPort());
@@ -697,7 +745,6 @@ void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
     mLandActor->SetPickable(0);
     mLandActor->SetVisibility(true);
     this->UpdateDisplayExtent();
-    this->GetRenderer()->AddActor(mLandActor);
   }
 }
 //------------------------------------------------------------------------------
@@ -824,10 +871,14 @@ void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
   if (mVF && mVFActor->GetVisibility()) {
     if (mVF->GetVTKImages().size() > (unsigned int)mCurrentTSlice)
 #if VTK_MAJOR_VERSION <= 5
-      mVOIFilter->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
+      mVFReslice->SetInput(mVF->GetVTKImages()[mCurrentTSlice]);
 #else
-      mVOIFilter->SetInputData(mVF->GetVTKImages()[mCurrentTSlice]);
+      mVFReslice->SetInputData(mVF->GetVTKImages()[mCurrentTSlice]);
 #endif
+      // Update overlay transform
+      mConcatenatedVFTransform->Identity();
+      mConcatenatedVFTransform->Concatenate(mVF->GetTransform()[mCurrentTSlice]);
+      mConcatenatedVFTransform->Concatenate(mSlicingTransform);
   }
   //update the overlay
   if (mOverlay && mOverlayActor->GetVisibility()) {
@@ -903,9 +954,9 @@ int vvSlicer::GetTSlice()
 int vvSlicer::GetMaxCurrentTSlice()
 { 
   int t = mCurrentTSlice;
-  if(mOverlay)
+  if(mOverlay && mOverlayActor->GetVisibility())
     t = std::max(t, mCurrentOverlayTSlice);
-  if(mFusion&& (mFusionSequenceCode<0)) //ignore fusionSequence data: for these, the times are not to be related (this way)
+  if(mFusion&& (mFusionSequenceCode<0) && mFusionActor->GetVisibility()) //ignore fusionSequence data: for these, the times are not to be related (this way)
     t = std::max(t, mCurrentFusionTSlice);
   return t;
 }
@@ -937,7 +988,7 @@ void vvSlicer::SetSliceOrientation(int orientation)
     copyExtent(ext, extent);
 #endif
 
-  if (extent[5]-extent[4] <= 2)
+  if (extent[5]-extent[4] < 1)
     orientation = vtkImageViewer2::SLICE_ORIENTATION_XY;
 
   if (orientation < vtkImageViewer2::SLICE_ORIENTATION_YZ ||
@@ -954,6 +1005,9 @@ void vvSlicer::SetSliceOrientation(int orientation)
   if(mOverlay)
     AdjustResliceToSliceOrientation(mOverlayReslice);
 
+  if(mVF)
+    AdjustResliceToSliceOrientation(mVFReslice);
+
   // Update the viewer
   
   // Go to current cursor position
@@ -1037,6 +1091,9 @@ void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice)
   reslice->SetOutputOrigin(origin);
   reslice->SetOutputSpacing(spacing);
   reslice->UpdateInformation();
+#if VTK_MAJOR_VERSION <= 5
+  reslice->GetOutput()->UpdateInformation();
+#endif
 }
 //------------------------------------------------------------------------------
 
@@ -1168,14 +1225,15 @@ void vvSlicer::UpdateDisplayExtent()
     offset = -1;
   
   if (mVF && mVFVisibility) {
+    AdjustResliceToSliceOrientation(mVFReslice);
     int vfExtent[6];
 #if VTK_MAJOR_VERSION <= 5
     mVF->GetVTKImages()[0]->UpdateInformation();
-    this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetVTKImages()[0], vfExtent);
+    this->ConvertImageToImageDisplayExtent(input, w_ext, mVFReslice->GetOutput(), vfExtent);
     bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
 #else
-    //this->UpdateInformation();
-    this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVF->GetVTKImages()[0], vfExtent);
+    mVOIFilter->Update();
+    this->ConvertImageToImageDisplayExtent(mImageReslice->GetOutputInformation(0), w_ext, mVFReslice->GetOutput(), vfExtent);
     bool out = ClipDisplayedExtent(vfExtent, mVOIFilter->GetInputInformation()->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()));
 #endif
     mVFActor->SetVisibility(!out);
@@ -1614,7 +1672,6 @@ double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, doubl
   //image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
   //image->Update();
 #endif
-
   return image->GetScalarComponentAsDouble(ix, iy, iz, component);
 }
 //----------------------------------------------------------------------------
@@ -1634,7 +1691,6 @@ void vvSlicer::Render()
   } else legend->SetVisibility(0);
 
   if (ca->GetVisibility()) {
-
     std::stringstream worldPos(" ");
     double pt[3];
     mConcatenatedTransform->TransformPoint(mCurrent, pt);
@@ -1648,25 +1704,6 @@ void vvSlicer::Render()
         Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[3]+0.5 &&
         Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[4]-0.5 &&
         Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetWholeExtent()[5]+0.5) {
-
-      
-      int ix, iy, iz;
-      double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
-
-      if(ImageActor->GetVisibility())
-        worldPos << "data value : " << value << std::endl;
-
-      worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
-                          << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
-                          << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
-                          << mCurrentTSlice
-                          << std::endl;
-      worldPos << "pixel : " << ix << ' '
-                             << iy << ' '
-                             << iz << ' '
-                             << mCurrentTSlice
-                             << std::endl;
-    }
 #else
     if (X >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[0]-0.5 &&
         X <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[1]+0.5 &&
@@ -1674,16 +1711,14 @@ void vvSlicer::Render()
         Y <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[3]+0.5 &&
         Z >= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[4]-0.5 &&
         Z <= mImage->GetVTKImages()[mCurrentTSlice]->GetInformation()->Get(vtkDataObject::DATA_EXTENT())[5]+0.5) {
-
+#endif
       int ix, iy, iz;
       double value = this->GetScalarComponentAsDouble(mImage->GetVTKImages()[mCurrentTSlice], X, Y, Z, ix, iy, iz);
-
       if(ImageActor->GetVisibility())
         worldPos << "data value : " << value << std::endl;
-
-      worldPos << "mm : " << lrint(mCurrentBeforeSlicingTransform[0]) << ' '
-                          << lrint(mCurrentBeforeSlicingTransform[1]) << ' '
-                          << lrint(mCurrentBeforeSlicingTransform[2]) << ' '
+      worldPos << "mm : " << lrint(mCurrent[0]) << ' '
+                          << lrint(mCurrent[1]) << ' '
+                          << lrint(mCurrent[2]) << ' '
                           << mCurrentTSlice
                           << std::endl;
       worldPos << "pixel : " << ix << ' '
@@ -1693,7 +1728,6 @@ void vvSlicer::Render()
                              << std::endl;
     
     }
-#endif
     ca->SetText(1,worldPos.str().c_str());
 
     std::stringstream slicePos;
@@ -1764,6 +1798,8 @@ void vvSlicer::Render()
     }
 #if VTK_MAJOR_VERSION <= 5
     mOverlayMapper->GetOutput()->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
+#elif VTK_MAJOR_VERSION >= 8 || (VTK_MAJOR_VERSION == 7 && VTK_MINOR_VERSION >= 1)
+    mOverlayMapper->UpdateExtent(mOverlayActor->GetDisplayExtent());
 #else
     mOverlayMapper->SetUpdateExtent(mOverlayActor->GetDisplayExtent());
 #endif
@@ -1772,6 +1808,8 @@ void vvSlicer::Render()
   if (mFusion && mFusionActor->GetVisibility()) {
 #if VTK_MAJOR_VERSION <= 5
     mFusionMapper->GetOutput()->SetUpdateExtent(mFusionActor->GetDisplayExtent());
+#elif VTK_MAJOR_VERSION >= 8 || (VTK_MAJOR_VERSION == 7 && VTK_MINOR_VERSION >= 1)
+    mFusionMapper->UpdateExtent(mFusionActor->GetDisplayExtent());
 #else
     mFusionMapper->SetUpdateExtent(mFusionActor->GetDisplayExtent());
 #endif
@@ -1802,7 +1840,7 @@ void vvSlicer::UpdateCursorPosition()
 //----------------------------------------------------------------------------
 void vvSlicer::RemoveLandmarks()
 { 
-  vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
+  vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
   if (pd->GetPoints()) {
 
     //First remove all captions:
@@ -1828,12 +1866,12 @@ void vvSlicer::DisplayLandmarks()
   mClipBox->SetBounds(bounds);
 
 
-  vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
+  vtkPolyData *pd = static_cast<vtkPolyData*>(mLandmarks->GetOutput());
   if (pd->GetPoints()) {
+    this->GetRenderer()->AddActor(mLandActor);
     //mLandGlyph->SetRange(0,1);
     //mLandGlyph->Modified();
     //mLandGlyph->Update();
-
     mClipBox->Modified();
     mLandClipper->Update();
     mLandMapper->Update();