X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvSlicer.cxx;h=2255cce74c5b8a719ec671caaddbea425636eb4b;hb=b29eb65e42740eaea460a8c503f3df05bb554ffe;hp=af7f0668941291455b37149ef79626eccfbd2d8f;hpb=8455690c8e536d1cec06bc62a80d23c6c78ca955;p=clitk.git

diff --git a/vv/vvSlicer.cxx b/vv/vvSlicer.cxx
index af7f066..2255cce 100644
--- a/vv/vvSlicer.cxx
+++ b/vv/vvSlicer.cxx
@@ -91,6 +91,9 @@ vvSlicer::vvSlicer()
   mScale = 1;
   mVFLog = 0;
   mVFWidth = 1;
+  mVFColor[0] = 0;
+  mVFColor[1] = 1;
+  mVFColor[2] = 0;
 
   std::string text = "F1 = sagital; F2 = coronal; F3 = axial\n";
   text += "F5 = horizontal flip; F6 = vertical flip\n\n";
@@ -264,6 +267,22 @@ bool vvSlicer::GetCursorVisibility()
 //------------------------------------------------------------------------------
 
 
+//------------------------------------------------------------------------------
+void vvSlicer::SetCornerAnnotationVisibility(bool s)
+{
+  ca->SetVisibility(s);
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+bool vvSlicer::GetCornerAnnotationVisibility()
+{
+  return ca->GetVisibility();
+}
+//------------------------------------------------------------------------------
+
+
 //------------------------------------------------------------------------------
 vvSlicer::~vvSlicer()
 {
@@ -428,11 +447,20 @@ void vvSlicer::SetVF(vvImage::Pointer vf)
     mGlyphFilter->SetVectorModeToUseVector();
     mGlyphFilter->SetColorModeToColorByVector();
 
+    if (!mVFColorLUT)
+      mVFColorLUT = vtkSmartPointer<vtkLookupTable>::New();
+
+    double mVFColorHSV[3];
+    vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
+    mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
+    mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
+    mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
+
     if (!mVFMapper)
       mVFMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    //mVFMapper->SetInputConnection(mGlyphFilter->GetOutputPort());
     mVFMapper->SetInput(mGlyphFilter->GetOutput());
     mVFMapper->ImmediateModeRenderingOn();
+    mVFMapper->SetLookupTable(mVFColorLUT);
 
     if (!mVFActor)
       mVFActor = vtkSmartPointer<vtkActor>::New();
@@ -682,7 +710,6 @@ int vvSlicer::GetOrientation()
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicer::UpdateDisplayExtent()
 {
@@ -691,181 +718,80 @@ void vvSlicer::UpdateDisplayExtent()
     return;
   }
   input->UpdateInformation();
-  int *w_ext;// = input->GetWholeExtent();
 
-  if (mUseReducedExtent) {
-    w_ext = mReducedExtent;
-  } else w_ext = input->GetWholeExtent();
-
-  switch (this->SliceOrientation) {
-  case vtkImageViewer2::SLICE_ORIENTATION_XY:
-    this->ImageActor->SetDisplayExtent(
-                                       w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice);
-    if (mVF && mVFActor->GetVisibility()) {
-      int vfExtent[6];
-      ComputeVFDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,vfExtent);
-      mVOIFilter->SetVOI(vfExtent);
-      mGlyphFilter->SetOrientation(1,1,0);
-      mVFMapper->Update();
-      // put the vector field between the image and the camera
-      if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
-        mVFActor->SetPosition(0,0,ImageActor->GetBounds()[5]+2);
-      else
-        mVFActor->SetPosition(0,0,ImageActor->GetBounds()[4]-2);
-    }
-    if (mOverlay && mOverlayActor->GetVisibility()) {
-      int overExtent[6];
-      ComputeOverlayDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,overExtent);
-      mOverlayActor->SetDisplayExtent(overExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
-        mOverlayActor->SetPosition(0,0,1);
-      else
-        mOverlayActor->SetPosition(0,0,-1);
-    }
-    if (mFusion && mFusionActor->GetVisibility()) {
-      int fusExtent[6];
-      ComputeFusionDisplayedExtent(w_ext[0], w_ext[1], w_ext[2], w_ext[3], this->Slice, this->Slice,fusExtent);
-      mFusionActor->SetDisplayExtent(fusExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
-        mFusionActor->SetPosition(0,0,1.5);
-      else
-        mFusionActor->SetPosition(0,0,-1.5);
-    }
-    if (mLandActor) {
-      if (mClipBox) {
-        double bounds [6];
-        bounds[0] = ImageActor->GetBounds()[0];
-        bounds[1] = ImageActor->GetBounds()[1];
-        bounds[2] = ImageActor->GetBounds()[2];
-        bounds[3] = ImageActor->GetBounds()[3];
-        bounds[4] = ImageActor->GetBounds()[4]-fabs(0.5/this->GetInput()->GetSpacing()[2]);
-        bounds[5] = ImageActor->GetBounds()[5]+fabs(0.5/this->GetInput()->GetSpacing()[2]);
-        mClipBox->SetBounds(bounds);
-        UpdateLandmarks();
-      }
-      // DD(mLandActor->GetPosition()[2]);
-      // DD(Renderer->GetActiveCamera()->GetPosition()[2]);
-      mLandActor->SetPosition(0,0,-1.5);
-      /*
-      if (Renderer->GetActiveCamera()->GetPosition()[2] > this->Slice)
-        mLandActor->SetPosition(0,0,1.5);
-      else
-        mLandActor->SetPosition(0,0,-1.5);
-      */
-    }
-    break;
-
-  case vtkImageViewer2::SLICE_ORIENTATION_XZ:
-    this->ImageActor->SetDisplayExtent(
-                                       w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5]);
-    if (mVF && mVFActor->GetVisibility()) {
-      int vfExtent[6];
-      ComputeVFDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],vfExtent);
-      mVOIFilter->SetVOI(vfExtent);
-      mGlyphFilter->SetOrientation(1,0,1);
-      mVFMapper->Update();
-      // put the vector field between the image aSpacingnd the camera
-      if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
-        mVFActor->SetPosition(0,ImageActor->GetBounds()[3]+2,0);
-      else
-        mVFActor->SetPosition(0,ImageActor->GetBounds()[2]-2,0);
-    }
-    if (mOverlay && mOverlayActor->GetVisibility()) {
-      int overExtent[6];
-      ComputeOverlayDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],overExtent);
-      mOverlayActor->SetDisplayExtent(overExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
-        mOverlayActor->SetPosition(0,1,0);
-      else
-        mOverlayActor->SetPosition(0,-1,0);
-    }
-    if (mFusion && mFusionActor->GetVisibility()) {
-      int fusExtent[6];
-      ComputeFusionDisplayedExtent(w_ext[0], w_ext[1], this->Slice, this->Slice, w_ext[4], w_ext[5],fusExtent);
-      mFusionActor->SetDisplayExtent(fusExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
-        mFusionActor->SetPosition(0,1.5,0);
-      else
-        mFusionActor->SetPosition(0,-1.5,0);
-    }
-    if (mLandActor) {
-      if (mClipBox) {
-        double bounds [6];
-        bounds[0] = ImageActor->GetBounds()[0];
-        bounds[1] = ImageActor->GetBounds()[1];
-        bounds[2] = ImageActor->GetBounds()[2]-fabs(0.5/this->GetInput()->GetSpacing()[1]);
-        bounds[3] = ImageActor->GetBounds()[3]+fabs(0.5/this->GetInput()->GetSpacing()[1]);
-        bounds[4] = ImageActor->GetBounds()[4];
-        bounds[5] = ImageActor->GetBounds()[5];
-        mClipBox->SetBounds(bounds);
-        UpdateLandmarks();
-      }
-      //      DD(mLandActor->GetPosition()[1]);
-      //DD(Renderer->GetActiveCamera()->GetPosition()[1]);
-      if (Renderer->GetActiveCamera()->GetPosition()[1] > this->Slice)
-        mLandActor->SetPosition(0,1.5,0);
-      else
-        mLandActor->SetPosition(0,-1.5,0);
-    }
-    break;
-
-  case vtkImageViewer2::SLICE_ORIENTATION_YZ:
-    this->ImageActor->SetDisplayExtent(
-                                       this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
-    if (mVF && mVFActor->GetVisibility()) {
-      int vfExtent[6];
-      ComputeVFDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],vfExtent);
-      mVOIFilter->SetVOI(vfExtent);
-      mGlyphFilter->SetOrientation(0,1,1);
-      mVFMapper->Update();
-      // put the vector field between the image and the camera
-      if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
-        mVFActor->SetPosition(ImageActor->GetBounds()[1]+2,0,0);
-      else
-        mVFActor->SetPosition(ImageActor->GetBounds()[0]-2,0,0);
-    }
-    if (mOverlay && mOverlayActor->GetVisibility()) {
-      int overExtent[6];
-      ComputeOverlayDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],overExtent);
-      mOverlayActor->SetDisplayExtent(overExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
-        mOverlayActor->SetPosition(1,0,0);
-      else
-        mOverlayActor->SetPosition(-1,0,0);
-    }
-    if (mFusion && mFusionActor->GetVisibility()) {
-      int fusExtent[6];
-      ComputeFusionDisplayedExtent(this->Slice, this->Slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5],fusExtent);
-      mFusionActor->SetDisplayExtent(fusExtent);
-      if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
-        mFusionActor->SetPosition(1.5,0,0);
-      else
-        mFusionActor->SetPosition(-1.5,0,0);
-    }
-    if (mLandActor) {
-      if (mClipBox) {
-        double bounds [6];
-        bounds[0] = ImageActor->GetBounds()[0]-fabs(0.5/this->GetInput()->GetSpacing()[0]);
-        bounds[1] = ImageActor->GetBounds()[1]+fabs(0.5/this->GetInput()->GetSpacing()[0]);
-        bounds[2] = ImageActor->GetBounds()[2];
-        bounds[3] = ImageActor->GetBounds()[3];
-        bounds[4] = ImageActor->GetBounds()[4];
-        bounds[5] = ImageActor->GetBounds()[5];
-        mClipBox->SetBounds(bounds);
-        UpdateLandmarks();
-      }
-      //      DD(mLandActor->GetPosition()[1]);
-      //      DD(Renderer->GetActiveCamera()->GetPosition()[1]);
-      if (Renderer->GetActiveCamera()->GetPosition()[0] > this->Slice)
-        mLandActor->SetPosition(1.5,0,0);
-      else
-        mLandActor->SetPosition(-1.5,0,0);
+  // Local copy of extent
+  int w_ext[6];
+  for(unsigned int i=0; i<6; i++){
+    if (mUseReducedExtent)
+      w_ext[i] = mReducedExtent[i];
+    else  
+      w_ext[i] = input->GetWholeExtent()[i];
+  }
+
+  // Set slice value
+  w_ext[ this->SliceOrientation*2   ] = this->Slice;
+  w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
+  
+  // Image actor
+  this->ImageActor->SetDisplayExtent(w_ext);
+  
+  // Position vector
+  double position[3] = {0.,0.,0.};
+  double positionInc = (Renderer->GetActiveCamera()->GetPosition()[this->SliceOrientation] > this->Slice)?10:-10;
+  position[this->SliceOrientation] += positionInc;
+  
+  // Overlay image actor
+  if (mOverlay && mOverlayActor->GetVisibility()) {
+    int overExtent[6];
+    mOverlay->GetTransformedVTKImages()[0]->UpdateInformation();
+    this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlay->GetTransformedVTKImages()[0], overExtent);
+    ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
+    mOverlayActor->SetDisplayExtent( overExtent );
+    mOverlayActor->SetPosition(position);
+  }
+  position[this->SliceOrientation] += positionInc;
+
+  // Fusion image actor
+  if (mFusion && mFusionActor->GetVisibility()) {
+    int fusExtent[6];
+    mFusion->GetTransformedVTKImages()[0]->UpdateInformation();
+    this->ConvertImageToImageDisplayExtent(input, w_ext, mFusion->GetTransformedVTKImages()[0], fusExtent);
+    ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
+    mFusionActor->SetDisplayExtent(fusExtent);
+    mFusionActor->SetPosition(position);
+  }
+  position[this->SliceOrientation] += positionInc;
+
+  // Vector field actor
+  if (mVF && mVFActor->GetVisibility()) {
+    int vfExtent[6];
+    mVF->GetTransformedVTKImages()[0]->UpdateInformation();
+    this->ConvertImageToImageDisplayExtent(input, w_ext, mVF->GetTransformedVTKImages()[0], vfExtent);
+    ClipDisplayedExtent(vfExtent, mVOIFilter->GetInput()->GetWholeExtent());
+    mVOIFilter->SetVOI(vfExtent);
+    int orientation[3] = {1,1,1};
+    orientation[this->SliceOrientation] = 0;
+    mGlyphFilter->SetOrientation(orientation[0], orientation[1], orientation[2]);
+    mVFMapper->Update();
+    mVFActor->SetPosition(position);
+  }
+  position[this->SliceOrientation] += positionInc;
+
+  // Landmarks actor
+  if (mLandActor) {
+    if (mClipBox) {
+      double bounds [6];
+      for(unsigned int i=0; i<6; i++)
+        bounds[i] = ImageActor->GetBounds()[i];
+      bounds[ this->SliceOrientation*2   ] = ImageActor->GetBounds()[ this->SliceOrientation*2  ]-fabs(0.5/this->GetInput()->GetSpacing()[this->SliceOrientation]);
+      bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(0.5/this->GetInput()->GetSpacing()[this->SliceOrientation]);
+      mClipBox->SetBounds(bounds);
+      UpdateLandmarks();
     }
-    break;
+    mLandActor->SetPosition(position);
   }
 
   // Figure out the correct clipping range
-
   if (this->Renderer) {
     if (this->InteractorStyle &&
         this->InteractorStyle->GetAutoAdjustCameraClippingRange()) {
@@ -881,79 +807,31 @@ void vvSlicer::UpdateDisplayExtent()
         double *spacing = input->GetSpacing();
         double avg_spacing =
           ((double)spacing[0] + (double)spacing[1] + (double)spacing[2]) / 3.0;
-        cam->SetClippingRange(
-                              range - avg_spacing * 3.0, range + avg_spacing * 3.0);
+        cam->SetClippingRange(range - avg_spacing * 3.0, range + avg_spacing * 3.0);
       }
     }
   }
 }
 //----------------------------------------------------------------------------
 
-
-//----------------------------------------------------------------------------
-void vvSlicer::ComputeVFDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int vfExtent[6])
-{
-  vtkImageData* image=this->GetInput();
-  vfExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
-    mVF->GetSpacing()[0];
-  vfExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mVF->GetOrigin()[0]) /
-    mVF->GetSpacing()[0];
-  vfExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
-    mVF->GetSpacing()[1];
-  vfExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mVF->GetOrigin()[1]) /
-    mVF->GetSpacing()[1];
-  vfExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
-    mVF->GetSpacing()[2];
-  vfExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mVF->GetOrigin()[2]) /
-    mVF->GetSpacing()[2];
-
-  ClipDisplayedExtent(vfExtent,mVOIFilter->GetInput()->GetWholeExtent());
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicer::ComputeOverlayDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int overExtent[6])
-{
-  vtkImageData* image=this->GetInput();
-  overExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
-    mOverlay->GetSpacing()[0];
-  overExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mOverlay->GetOrigin()[0]) /
-    mOverlay->GetSpacing()[0];
-  overExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
-    mOverlay->GetSpacing()[1];
-  overExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mOverlay->GetOrigin()[1]) /
-    mOverlay->GetSpacing()[1];
-  overExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
-    mOverlay->GetSpacing()[2];
-  overExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mOverlay->GetOrigin()[2]) /
-    mOverlay->GetSpacing()[2];
-  ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
-}
-//----------------------------------------------------------------------------
-
-
 //----------------------------------------------------------------------------
-void vvSlicer::ComputeFusionDisplayedExtent(int x1,int x2,int y1,int y2,int z1,int z2,int fusExtent[6])
+void vvSlicer::ConvertImageToImageDisplayExtent(vtkImageData *sourceImage, const int sourceExtent[6],
+                                                vtkImageData *targetImage, int targetExtent[6])
 {
-  vtkImageData* image=this->GetInput();
-  fusExtent[0] = (( image->GetOrigin()[0] + x1*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
-    mFusion->GetSpacing()[0];
-  fusExtent[1] = (( image->GetOrigin()[0] + x2*image->GetSpacing()[0] ) - mFusion->GetOrigin()[0]) /
-    mFusion->GetSpacing()[0];
-  fusExtent[2] = (( image->GetOrigin()[1] + y1*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
-    mFusion->GetSpacing()[1];
-  fusExtent[3] = (( image->GetOrigin()[1] + y2*image->GetSpacing()[1] ) - mFusion->GetOrigin()[1]) /
-    mFusion->GetSpacing()[1];
-  fusExtent[4] = (( image->GetOrigin()[2] + z1*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
-    mFusion->GetSpacing()[2];
-  fusExtent[5] = (( image->GetOrigin()[2] + z2*image->GetSpacing()[2] ) - mFusion->GetOrigin()[2]) /
-    mFusion->GetSpacing()[2];
-  ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
+  double dExtents[6];
+  for(unsigned int i=0; i<6; i++) {
+    // From source voxel coordinates to world coordinates
+    dExtents[i] = sourceImage->GetOrigin()[i/2] + sourceImage->GetSpacing()[i/2] * sourceExtent[i];
+
+    // From world coordinates to floating point target voxel coordinates
+    dExtents[i] = (dExtents[i]- targetImage->GetOrigin()[i/2]) / targetImage->GetSpacing()[i/2];
+    
+    // Round to nearest
+    targetExtent[i] = itk::Math::Round(dExtents[i]);
+  }
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
 {
@@ -1202,6 +1080,26 @@ void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max)
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, int X, double Y, double Z, int &ix, int &iy, int &iz, int component)
+{
+  ix = lrint(X);
+  iy = lrint(Y);
+  iz = lrint(Z);
+  if (ix < image->GetWholeExtent()[0] ||
+      ix > image->GetWholeExtent()[1] ||
+      iy < image->GetWholeExtent()[2] ||
+      iy > image->GetWholeExtent()[3] ||
+      iz < image->GetWholeExtent()[4] ||
+      iz > image->GetWholeExtent()[5] )
+    return sqrt(-1.);
+
+  image->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
+  image->Update();
+  return image->GetScalarComponentAsDouble(ix, iy, iz, component);
+}
+//----------------------------------------------------------------------------
+
 //----------------------------------------------------------------------------
 void vvSlicer::Render()
 {
@@ -1221,32 +1119,13 @@ void vvSlicer::Render()
     double X = (mCurrent[0] - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
     double Y = (mCurrent[1] - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
     double Z = (mCurrent[2] - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
-
-    if (pdmA->GetVisibility()) {
-      double x = mCursor[0];
-      double y = mCursor[1];
-      double z = mCursor[2];
-      double xCursor = (x - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
-      double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
-      double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
-
-      if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0] &&
-          xCursor < this->GetImageActor()->GetDisplayExtent()[1]+1 &&
-          yCursor >= this->GetImageActor()->GetDisplayExtent()[2] &&
-          yCursor < this->GetImageActor()->GetDisplayExtent()[3]+1 &&
-          zCursor >= this->GetImageActor()->GetDisplayExtent()[4] &&
-          zCursor < this->GetImageActor()->GetDisplayExtent()[5]+1 ) {
-        vtkRenderer * renderer = this->Renderer;
-
-        renderer->WorldToView(x,y,z);
-        renderer->ViewToNormalizedViewport(x,y,z);
-        renderer->NormalizedViewportToViewport(x,y);
-        renderer->ViewportToNormalizedDisplay(x,y);
-        renderer->NormalizedDisplayToDisplay(x,y);
-        crossCursor->SetFocalPoint(x,y,z);
-      } else
-        crossCursor->SetFocalPoint(-1,-1,z);
-    }
+    
+//     if (X < this->GetInput()->GetWholeExtent()[0]) X = this->GetInput()->GetWholeExtent()[0];
+//     else if (X > this->GetInput()->GetWholeExtent()[1]) X = this->GetInput()->GetWholeExtent()[1]; 
+//     if (Y < this->GetInput()->GetWholeExtent()[2]) Y = this->GetInput()->GetWholeExtent()[2];
+//     else if (Y > this->GetInput()->GetWholeExtent()[3]) Y = this->GetInput()->GetWholeExtent()[3]; 
+//     if (Z < this->GetInput()->GetWholeExtent()[4]) Z = this->GetInput()->GetWholeExtent()[4];
+//     else if (Z > this->GetInput()->GetWholeExtent()[5]) Z = this->GetInput()->GetWholeExtent()[5]; 
 
     if (X >= this->GetInput()->GetWholeExtent()[0] &&
         X <= this->GetInput()->GetWholeExtent()[1] &&
@@ -1254,9 +1133,11 @@ void vvSlicer::Render()
         Y <= this->GetInput()->GetWholeExtent()[3] &&
         Z >= this->GetInput()->GetWholeExtent()[4] &&
         Z <= this->GetInput()->GetWholeExtent()[5]) {
-      int ix = lrint(X);
-      int iy = lrint(Y);
-      int iz = lrint(Z);
+
+      
+      int ix, iy, iz;
+      double value = this->GetScalarComponentAsDouble(this->GetInput(), X, Y, Z, ix, iy, iz);
+
       std::stringstream pixel1;
       std::stringstream pixel2;
       std::stringstream pixel3;
@@ -1265,9 +1146,6 @@ void vvSlicer::Render()
       pixel2 << iy;
       pixel3 << iz;
       temps << mCurrentTSlice;
-      this->GetInput()->SetUpdateExtent(ix, ix, iy, iy, iz, iz);
-      this->GetInput()->Update();
-      double value = this->GetInput()->GetScalarComponentAsDouble(ix, iy, iz, 0);
 
       std::stringstream val;
       val << value;
@@ -1279,6 +1157,34 @@ void vvSlicer::Render()
     }
     ca->SetText(1,worldPos.c_str());
   }
+
+  if (pdmA->GetVisibility()) {
+    double x = mCursor[0];
+    double y = mCursor[1];
+    double z = mCursor[2];
+    double xCursor = (x - this->GetInput()->GetOrigin()[0])/this->GetInput()->GetSpacing()[0];
+    double yCursor = (y - this->GetInput()->GetOrigin()[1])/this->GetInput()->GetSpacing()[1];
+    double zCursor = (z - this->GetInput()->GetOrigin()[2])/this->GetInput()->GetSpacing()[2];
+
+    if (xCursor >= this->GetImageActor()->GetDisplayExtent()[0] &&
+        xCursor < this->GetImageActor()->GetDisplayExtent()[1]+1 &&
+        yCursor >= this->GetImageActor()->GetDisplayExtent()[2] &&
+        yCursor < this->GetImageActor()->GetDisplayExtent()[3]+1 &&
+        zCursor >= this->GetImageActor()->GetDisplayExtent()[4] &&
+        zCursor < this->GetImageActor()->GetDisplayExtent()[5]+1 ) {
+      vtkRenderer * renderer = this->Renderer;
+
+      renderer->WorldToView(x,y,z);
+      renderer->ViewToNormalizedViewport(x,y,z);
+      renderer->NormalizedViewportToViewport(x,y);
+      renderer->ViewportToNormalizedDisplay(x,y);
+      renderer->NormalizedDisplayToDisplay(x,y);
+      crossCursor->SetFocalPoint(x,y,z);
+    } else
+      crossCursor->SetFocalPoint(-1,-1,z);
+  }
+
+
   if (mOverlay && mOverlayActor->GetVisibility()) {
     mOverlayMapper->SetWindow(this->GetColorWindow());
     mOverlayMapper->SetLevel(this->GetColorLevel());
@@ -1288,7 +1194,7 @@ void vvSlicer::Render()
   }
   if (mLandMapper)
     UpdateLandmarks();
-  //this->Superclass::Render();
+
   this->GetRenderWindow()->Render();
 }
 //----------------------------------------------------------------------------
@@ -1348,7 +1254,7 @@ void vvSlicer::SetSlice(int slice)
   this->UpdateDisplayExtent();
 
   // Seems to work without this line
-  //  this->Render();
+  //this->Render();
 }
 //----------------------------------------------------------------------------
 
@@ -1388,9 +1294,19 @@ void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
 }
 //----------------------------------------------------------------------------
 
-
-
-
-
-
+//----------------------------------------------------------------------------
+void vvSlicer::SetVFColor(double r, double g, double b)
+{
+  double mVFColorHSV[3];
+  mVFColor[0] = r;
+  mVFColor[1] = g;
+  mVFColor[2] = b;
+
+  vtkMath::RGBToHSV(mVFColor, mVFColorHSV);
+  mVFColorLUT->SetHueRange(mVFColorHSV[0], mVFColorHSV[0]);
+  mVFColorLUT->SetSaturationRange(mVFColorHSV[1],mVFColorHSV[1]);
+  mVFColorLUT->SetValueRange(mVFColorHSV[2], mVFColorHSV[2]);
+
+  this->Render();
+}