Merge branch 'release' into HEAD

* release: (25 commits)
  Fixed volume rendering not working for cell data
  Fixed typo which resulted in test failure
  Added API to turn on/off jittering
  Fixed edge conditions with clipping
  ...

Primarily brings in volume rendering fixes.

Rendering/Volume/Testing/Cxx/CMakeLists.txt

@@ -54,6 +54,7 @@ endif()
 set (VolumeOpenGL2CxxTests
   TestGPURayCastCameraInside.cxx
   TestGPURayCastCameraInsideSmallSpacing.cxx
+  TestGPURayCastCellData.cxx
   TestGPURayCastClipping.cxx
   TestGPURayCastGradientOpacity.cxx
   TestGPURayCastPositionalLights.cxx

Rendering/Volume/Testing/Cxx/TestGPURayCastCellData.cxx

+
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    TestGPURayCastVolumeUpdate.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+// This test volume tests whether updating the volume MTime updates the ,
+// geometry in the volume mapper.
+
+#include <vtkColorTransferFunction.h>
+#include <vtkDataArray.h>
+#include <vtkGPUVolumeRayCastMapper.h>
+#include <vtkImageData.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+#include <vtkNew.h>
+#include <vtkOutlineFilter.h>
+#include <vtkPiecewiseFunction.h>
+#include <vtkPointDataToCellData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkRegressionTestImage.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRTAnalyticSource.h>
+#include <vtkSmartPointer.h>
+#include <vtkTesting.h>
+#include <vtkTestUtilities.h>
+#include <vtkVolumeProperty.h>
+#include <vtkXMLImageDataReader.h>
+
+
+int TestGPURayCastCellData(int argc, char *argv[])
+{
+  cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
+
+  double scalarRange[2];
+
+  vtkNew<vtkActor> outlineActor;
+  vtkNew<vtkPolyDataMapper> outlineMapper;
+  vtkNew<vtkGPUVolumeRayCastMapper> volumeMapper;
+
+  vtkNew<vtkXMLImageDataReader> reader;
+  char* volumeFile = vtkTestUtilities::ExpandDataFileName(
+                            argc, argv, "Data/vase_1comp.vti");
+  reader->SetFileName(volumeFile);
+  delete[] volumeFile;
+
+  vtkNew<vtkPointDataToCellData> pointToCell;
+  pointToCell->SetInputConnection(reader->GetOutputPort());
+  volumeMapper->SetInputConnection(pointToCell->GetOutputPort());
+
+  // Add outline filter
+  vtkNew<vtkOutlineFilter> outlineFilter;
+  outlineFilter->SetInputConnection(pointToCell->GetOutputPort());
+  outlineMapper->SetInputConnection(outlineFilter->GetOutputPort());
+  outlineActor->SetMapper(outlineMapper.GetPointer());
+
+  volumeMapper->GetInput()->GetScalarRange(scalarRange);
+  volumeMapper->SetSampleDistance(0.1);
+  volumeMapper->SetAutoAdjustSampleDistances(0);
+  volumeMapper->SetBlendModeToComposite();
+
+  vtkNew<vtkRenderWindow> renWin;
+  renWin->SetMultiSamples(0);
+  renWin->SetSize(400, 400);
+
+  vtkNew<vtkRenderWindowInteractor> iren;
+  iren->SetRenderWindow(renWin.GetPointer());
+  vtkNew<vtkInteractorStyleTrackballCamera> style;
+  iren->SetInteractorStyle(style.GetPointer());
+
+  renWin->Render(); // make sure we have an OpenGL context.
+
+  vtkNew<vtkRenderer> ren;
+  ren->SetBackground(0.2, 0.2, 0.5);
+  renWin->AddRenderer(ren.GetPointer());
+
+  vtkNew<vtkPiecewiseFunction> scalarOpacity;
+  scalarOpacity->AddPoint(50, 0.0);
+  scalarOpacity->AddPoint(75, 1.0);
+
+  vtkNew<vtkVolumeProperty> volumeProperty;
+  volumeProperty->ShadeOn();
+  volumeProperty->SetInterpolationType(VTK_LINEAR_INTERPOLATION);
+  volumeProperty->SetScalarOpacity(scalarOpacity.GetPointer());
+
+  vtkNew<vtkColorTransferFunction> colorTransferFunction;
+  colorTransferFunction->RemoveAllPoints();
+  colorTransferFunction->AddRGBPoint(scalarRange[0], 0.6, 0.4, 0.1);
+  volumeProperty->SetColor(colorTransferFunction.GetPointer());
+
+  vtkNew<vtkVolume> volume;
+  volume->SetMapper(volumeMapper.GetPointer());
+  volume->SetProperty(volumeProperty.GetPointer());
+
+  ren->AddVolume(volume.GetPointer());
+  ren->AddActor(outlineActor.GetPointer());
+  ren->ResetCamera();
+
+  renWin->Render();
+  ren->ResetCamera();
+
+  iren->Initialize();
+
+  int retVal = vtkRegressionTestImage( renWin.GetPointer() );
+  if( retVal == vtkRegressionTester::DO_INTERACTOR)
+    {
+    iren->Start();
+    }
+
+  return !retVal;
+}

Rendering/Volume/Testing/Cxx/TestGPURayCastClipping.cxx

@@ -81,7 +81,8 @@ int TestGPURayCastClipping(int argc, char *argv[])
   clipPlane1->SetNormal(0.8, 0.0, 0.0);
 
   vtkNew<vtkPlane> clipPlane2;
-  clipPlane2->SetOrigin(0.0, 0.35 * (bounds[2] + bounds[3]), 0.0);
+  clipPlane2->SetOrigin(0.45 * (bounds[0] + bounds[1]),
+                        0.35 * (bounds[2] + bounds[3]), 0.0);
   clipPlane2->SetNormal(0.2, -0.2, 0.0);
 
   vtkNew<vtkPlaneCollection> clipPlaneCollection;

Rendering/Volume/Testing/Data/Baseline/TestGPURayCastCellData.png.md5

+e4bf697e218a4ef0d503b408d1af4448

Rendering/Volume/Testing/Data/Baseline/TestGPURayCastClipping.png.md5

-8a9b985a6e629a234bc8d8d343b2c8a2
+54622bc7c096d584f32fdf60b4d6495f

Rendering/Volume/vtkGPUVolumeRayCastMapper.cxx

@@ -45,6 +45,7 @@ vtkGPUVolumeRayCastMapper::vtkGPUVolumeRayCastMapper()
   this->MinimumImageSampleDistance = 1.0;
   this->MaximumImageSampleDistance = 10.0;
   this->RenderToImage              = 0;
+  this->UseJittering               = 1;
   this->SampleDistance             = 1.0;
   this->SmallVolumeRender          = 0;
   this->BigTimeToDraw              = 0.0;

Rendering/Volume/vtkGPUVolumeRayCastMapper.h

@@ -46,6 +46,14 @@ public:
   vtkGetMacro( AutoAdjustSampleDistances, int );
   vtkBooleanMacro( AutoAdjustSampleDistances, int );
 
+  // Description:
+  // If UseJittering is on, each ray traversal direction will be
+  // perturbed slightly using a noise-texture to get rid of wood-grain
+  // effect.
+  vtkSetClampMacro( UseJittering, int, 0, 1 );
+  vtkGetMacro( UseJittering, int );
+  vtkBooleanMacro( UseJittering, int );
+
   // Description:
   // Set/Get the distance between samples used for rendering
   // when AutoAdjustSampleDistances is off, or when this mapper
@@ -276,6 +284,9 @@ protected:
   // Render to texture mode flag
   int RenderToImage;
 
+  // Enable / disable stochasting jittering
+  int UseJittering;
+
   // The distance between sample points along the ray
   float  SampleDistance;
 

Rendering/VolumeOpenGL2/shaders/raycasterfs.glsl

@@ -42,6 +42,7 @@ vec3 g_dataPos;
 vec3 g_dirStep;
 vec4 g_srcColor;
 vec4 g_eyePosObj;
+bool g_exit;
 
 uniform vec4 in_volume_scale;
 uniform vec4 in_volume_bias;
@@ -88,6 +89,7 @@ void main()
   g_fragColor = vec4(0.0);
   g_dirStep = vec3(0.0);
   g_srcColor = vec4(0.0);
+  g_exit = false;
 
   //VTK::Base::Init
 
@@ -102,7 +104,7 @@ void main()
   //VTK::RenderToImage::Depth::Init
 
   /// For all samples along the ray
-  while (true)
+  while (!g_exit)
     {
     //VTK::Base::Impl
 

Rendering/VolumeOpenGL2/vtkOpenGLGPUVolumeRayCastMapper.cxx

@@ -731,6 +731,16 @@ bool vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::LoadVolume(
   // Update texture size
   imageData->GetExtent(this->Extents);
 
+  if (this->Parent->CellFlag)
+    {
+    int i = 1;
+    while (i < 6)
+      {
+      this->Extents[i]--;
+      i += 2;
+      }
+    }
+
   int i = 0;
   while(i < 3)
     {
@@ -929,6 +939,17 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::ComputeBounds(
   input->GetOrigin(origin);
   input->GetExtent(this->Extents);
 
+
+  if (this->Parent->CellFlag)
+    {
+    int i = 1;
+    while (i < 6)
+      {
+      this->Extents[i]--;
+      i += 2;
+      }
+    }
+
   int swapBounds[3];
   swapBounds[0] = (this->CellSpacing[0] < 0);
   swapBounds[1] = (this->CellSpacing[1] < 0);
@@ -1790,7 +1811,7 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::UpdateCropping(
                             static_cast<float>(croppingRegionPlanes[4]),
                             static_cast<float>(croppingRegionPlanes[5]) };
 
-    this->ShaderProgram->SetUniform1fv("cropping_planes", 6, cropPlanes);
+    this->ShaderProgram->SetUniform1fv("in_croppingPlanes", 6, cropPlanes);
     const int numberOfRegions = 32;
     int cropFlagsArray[numberOfRegions];
     cropFlagsArray[0] = 0;
@@ -1806,7 +1827,7 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::UpdateCropping(
       cropFlagsArray[i] = 0;
       }
 
-    this->ShaderProgram->SetUniform1iv("cropping_flags",
+    this->ShaderProgram->SetUniform1iv("in_croppingFlags",
                                        numberOfRegions,
                                        cropFlagsArray);
     }
@@ -1839,11 +1860,8 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::UpdateClipping(
       clippingPlanes.push_back(planeNormal[2]);
       }
 
-    double croppingRegionPlanes[6];
-    this->Parent->GetCroppingRegionPlanes(croppingRegionPlanes);
-
-    clippingPlanes[0] = clippingPlanes.size() > 0 ?
-      (clippingPlanes.size() - 1) : 0;
+    clippingPlanes[0] = clippingPlanes.size() > 1 ?
+                          static_cast<int>(clippingPlanes.size() - 1): 0;
 
     this->ShaderProgram->SetUniform1fv("in_clippingPlanes",
                                        static_cast<int>(clippingPlanes.size()),
@@ -3177,6 +3195,7 @@ void vtkOpenGLGPUVolumeRayCastMapper::GPURender(vtkRenderer* ren,
                        1.0 / this->Impl->WindowSize[1], fvalue2);
   this->Impl->ShaderProgram->SetUniform2fv("in_inverseWindowSize", 1, &fvalue2);
 
+  this->Impl->ShaderProgram->SetUniformi("in_useJittering", this->GetUseJittering());
   this->Impl->ShaderProgram->SetUniformi("in_cellFlag", this->CellFlag);
 
   // Updating cropping if enabled