Merge commit '2140f97b' into release

Rendering/OpenGL2/vtkTextureObject.cxx

@@ -2035,6 +2035,19 @@ void vtkTextureObject::CopyFromFrameBuffer(int srcXmin,
   vtkOpenGLCheckErrorMacro("failed at glCopyTexImage2D " << this->Format);
 }
 
+//----------------------------------------------------------------------------
+int vtkTextureObject::GetMaximumTextureSize(vtkOpenGLRenderWindow* context)
+{
+  int maxSize = -1;
+
+  if (context && context->IsCurrent())
+    {
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+    }
+
+  return maxSize;
+}
+
 //----------------------------------------------------------------------------
 void vtkTextureObject::PrintSelf(ostream& os, vtkIndent indent)
 {

Rendering/OpenGL2/vtkTextureObject.h

@@ -528,6 +528,16 @@ public:
   vtkGetMacro(GenerateMipmap,bool);
   vtkSetMacro(GenerateMipmap,bool);
 
+  // Description:
+  // Query and return maximum texture size (dimension) supported by the
+  // OpenGL driver for a particular context. It should be noted that this
+  // size does not consider the internal format of the texture and therefore
+  // there is no guarentee that a texture of this size will be allocated by
+  // the driver. Also, the method does not make the context current so
+  // if the passed context is not valid or current, a value of -1 will
+  // be returned.
+  static int GetMaximumTextureSize(vtkOpenGLRenderWindow* context);
+
   // Description:
   // Returns if the context supports the required extensions. If flags
   // for optional extenisons are set then the test fails when support
@@ -590,8 +600,6 @@ public:
                            int width,
                            int height);
 
-
-
 protected:
   vtkTextureObject();
   ~vtkTextureObject();

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
@@ -63,6 +64,7 @@ set (VolumeOpenGL2CxxTests
   TestGPURayCastRenderToTexture.cxx
   TestGPURayCastThreeComponentsIndependent.cxx
   TestGPURayCastTwoComponentsDependent.cxx
+  TestGPURayCastTwoComponentsGradient.cxx
   TestGPURayCastTwoComponentsIndependent.cxx
   TestGPURayCastVolumeLightKit.cxx
   TestGPURayCastVolumePolyData.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/Cxx/TestGPURayCastTwoComponentsGradient.cxx

+#include <vtkSmartPointer.h>
+#include <vtkPlanes.h>
+#include <vtkCamera.h>
+#include <vtkSphereSource.h>
+
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkPolyData.h>
+#include <vtkPointData.h>
+
+
+/*=========================================================================
+Program:   Visualization Toolkit
+Module:    TestGPURayCastTwoComponentsIndependent.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.
+=========================================================================*/
+
+// Description
+// This test creates a vtkImageData with two components.
+// The data is volume rendered considering the two components as independent.
+
+#include "vtkCamera.h"
+#include "vtkColorTransferFunction.h"
+#include "vtkGPUVolumeRayCastMapper.h"
+#include "vtkImageData.h"
+#include "vtkNew.h"
+#include "vtkPiecewiseFunction.h"
+#include "vtkRegressionTestImage.h"
+#include "vtkRenderer.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkTesting.h"
+#include "vtkTestUtilities.h"
+#include "vtkVolume.h"
+#include "vtkVolumeProperty.h"
+#include "vtkUnsignedShortArray.h"
+
+int TestGPURayCastTwoComponentsGradient(int argc, char *argv[])
+{
+  cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
+
+  int dims[3] = { 35, 35, 35 };
+
+  // Create a vtkImageData with two components
+  vtkNew<vtkImageData> image;
+  image->SetDimensions(dims[0], dims[1], dims[2]);
+  image->AllocateScalars(VTK_DOUBLE, 2);
+
+  // Fill the first half rectangular parallelopiped along X with the
+  // first component values and the second half with second component values
+  double * ptr = static_cast<double *> (image->GetScalarPointer(0, 0, 0));
+
+  for (int z = 0; z < dims[2]; ++z)
+  {
+    for (int y = 0; y < dims[1]; ++y)
+    {
+      for (int x = 0; x < dims[0]; ++x)
+      {
+        if (x < dims[0] / 2)
+        {
+          *ptr++ = 0.0;
+          *ptr++ = 0.0;
+        }
+        else
+        {
+          *ptr++ = 1.0;
+          *ptr++ = 1.0;
+        }
+      }
+    }
+  }
+
+  vtkNew<vtkRenderWindow> renWin;
+  renWin->SetSize(301, 300); // Intentional NPOT size
+  renWin->SetMultiSamples(0);
+
+  vtkNew<vtkRenderer> ren;
+  renWin->AddRenderer(ren.GetPointer());
+
+  vtkNew<vtkRenderWindowInteractor> iren;
+  iren->SetRenderWindow(renWin.GetPointer());
+
+  renWin->Render();
+
+  // Volume render the dataset
+  vtkNew<vtkGPUVolumeRayCastMapper> mapper;
+  mapper->AutoAdjustSampleDistancesOff();
+  mapper->SetSampleDistance(0.9);
+  mapper->SetInputData(image.GetPointer());
+
+  // Color transfer function
+  vtkNew<vtkColorTransferFunction> ctf1;
+  ctf1->AddRGBPoint(0.0, 0.0, 0.0, 0.0);
+  ctf1->AddRGBPoint(1.0, 1.0, 0.0, 0.0);
+
+  vtkNew<vtkColorTransferFunction> ctf2;
+  ctf2->AddRGBPoint(0.0, 0.0, 0.0, 0.0);
+  ctf2->AddRGBPoint(1.0, 0.0, 0.0, 1.0);
+
+  // Opacity functions
+  vtkNew<vtkPiecewiseFunction> pf1;
+  pf1->AddPoint(0.0, 0.0);
+  pf1->AddPoint(1.0, 1.0);
+
+  vtkNew<vtkPiecewiseFunction> pf2;
+  pf2->AddPoint(0.0, 0.0);
+  pf2->AddPoint(1.0, 1.0);
+
+  // Gradient Opacity function
+  vtkNew<vtkPiecewiseFunction> pf3;
+  pf3->AddPoint(0.0, 0.0);
+  pf3->AddPoint(1.0, 1.0);
+
+  vtkNew<vtkPiecewiseFunction> pf4;
+  pf4->AddPoint(0.0, 0.0);
+  pf4->AddPoint(1.0, 1.0);
+
+  // Volume property with independent components ON
+  vtkNew<vtkVolumeProperty> property;
+  property->IndependentComponentsOn();
+
+  // Set color and opacity functions
+  property->SetColor(0, ctf1.GetPointer());
+  property->SetColor(1, ctf2.GetPointer());
+  property->SetScalarOpacity(0, pf1.GetPointer());
+  property->SetScalarOpacity(1, pf2.GetPointer());
+  property->SetGradientOpacity(0, pf3.GetPointer());
+  property->SetGradientOpacity(1, pf4.GetPointer());
+
+  vtkNew<vtkVolume> volume;
+  volume->SetMapper(mapper.GetPointer());
+  volume->SetProperty(property.GetPointer());
+  ren->AddVolume(volume.GetPointer());
+
+  ren->ResetCamera();
+  renWin->Render();
+
+  iren->Initialize();
+
+  int retVal = vtkRegressionTestImage( renWin.GetPointer() );
+  if( retVal == vtkRegressionTester::DO_INTERACTOR)
+    {
+    iren->Start();
+    }
+
+  return !retVal;
+}

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

+e4bf697e218a4ef0d503b408d1af4448

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

-8a9b985a6e629a234bc8d8d343b2c8a2
+54622bc7c096d584f32fdf60b4d6495f

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

+6b2227f279b35214a3c74b581a5e29a6

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

@@ -112,6 +112,11 @@ public:
     this->TextureSize[0] = this->TextureSize[1] = this->TextureSize[2] = -1;
     this->WindowLowerLeft[0] = this->WindowLowerLeft[1] = 0;
     this->WindowSize[0] = this->WindowSize[1] = 0;
+    this->ScalarsRange[0][0] = this->ScalarsRange[0][1] = 0.0;
+    this->ScalarsRange[1][0] = this->ScalarsRange[1][1] = 0.0;
+    this->ScalarsRange[2][0] = this->ScalarsRange[2][1] = 0.0;
+    this->ScalarsRange[3][0] = this->ScalarsRange[3][1] = 0.0;
+
 
     this->CellScale[0] = this->CellScale[1] = this->CellScale[2] = 0.0;
     this->NoiseTextureData = 0;
@@ -128,7 +133,6 @@ public:
 
     this->MaskTextures = new vtkMapMaskTextureId;
 
-    this->ScalarsRange.clear();
     this->Scale.clear();
     this->Bias.clear();
 
@@ -181,7 +185,6 @@ public:
 
     delete this->MaskTextures;
 
-    this->ScalarsRange.clear();
     this->Scale.clear();
     this->Bias.clear();
     }
@@ -201,6 +204,8 @@ public:
   static void ToFloat(T (&in)[2], float (&out)[2]);
   template<typename T>
   static void ToFloat(T& in, float& out);
+  template<typename T>
+  static void ToFloat(T (&in)[4][2], float (&out)[4][2]);
 
   void Initialize(vtkRenderer* ren, vtkVolume* vol,
                   int noOfComponents, int independentComponents);
@@ -316,9 +321,8 @@ public:
   int TextureSize[3];
   int WindowLowerLeft[2];
   int WindowSize[2];
-  int LastWindowSize[2];
 
-  std::vector< std::vector<double> > ScalarsRange;
+  double ScalarsRange[4][2];
   double LoadedBounds[6];
   int Extents[6];
   double DatasetStepSize[3];
@@ -432,6 +436,21 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::ToFloat(
   out = static_cast<float>(in);
 }
 
+//----------------------------------------------------------------------------
+template<typename T>
+void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::ToFloat(
+  T (&in)[4][2], float (&out)[4][2])
+{
+  out[0][0] = static_cast<float>(in[0][0]);
+  out[0][1] = static_cast<float>(in[0][1]);
+  out[1][0] = static_cast<float>(in[1][0]);
+  out[1][1] = static_cast<float>(in[1][1]);
+  out[2][0] = static_cast<float>(in[2][0]);
+  out[2][1] = static_cast<float>(in[2][1]);
+  out[3][0] = static_cast<float>(in[3][0]);
+  out[3][1] = static_cast<float>(in[3][1]);
+}
+
 //----------------------------------------------------------------------------
 void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::Initialize(
   vtkRenderer* vtkNotUsed(ren), vtkVolume* vol, int
@@ -699,8 +718,8 @@ bool vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::LoadVolume(
 
   for (int n = 0; n < noOfComponents; ++n)
     {
-    double oglA = this->ScalarsRange[n][0]*oglScale + oglBias;
-    double oglB = this->ScalarsRange[n][1]*oglScale + oglBias;
+    double oglA = this->ScalarsRange[n][0] * oglScale + oglBias;
+    double oglB = this->ScalarsRange[n][1] * oglScale + oglBias;
     scale[n] = 1.0/ (oglB - oglA);
     bias[n] = 0.0 - oglA*scale[n];
     }
@@ -712,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)
     {
@@ -910,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);
@@ -1771,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;
@@ -1787,7 +1827,7 @@ void vtkOpenGLGPUVolumeRayCastMapper::vtkInternal::UpdateCropping(
       cropFlagsArray[i] = 0;
       }
 
-    this->ShaderProgram->SetUniform1iv("cropping_flags",
+    this->ShaderProgram->SetUniform1iv("in_croppingFlags",
                                        numberOfRegions,
                                        cropFlagsArray);
     }
@@ -1820,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()),
@@ -2252,8 +2289,9 @@ void vtkOpenGLGPUVolumeRayCastMapper::BuildShader(vtkRenderer* ren,
     fragmentShader,
     "//VTK::Base::Dec",
     vtkvolume::BaseDeclarationFragment(ren, this, vol, this->Impl->NumberOfLights,
-                                       this->Impl->LightComplexity, noOfComponents,
-                                       independentComponents),
+                                       this->Impl->LightComplexity,
+                                       vol->GetProperty()->HasGradientOpacity(),
+                                       noOfComponents, independentComponents),
     true);
 
   fragmentShader = vtkvolume::replace(
@@ -2390,7 +2428,6 @@ void vtkOpenGLGPUVolumeRayCastMapper::BuildShader(vtkRenderer* ren,
     "//VTK::Cropping::Dec",
     vtkvolume::CroppingDeclarationVertex(ren, this, vol),
     true);
-
   fragmentShader = vtkvolume::replace(
     fragmentShader,
     "//VTK::Cropping::Dec",
@@ -2743,11 +2780,6 @@ void vtkOpenGLGPUVolumeRayCastMapper::GPURender(vtkRenderer* ren,
 
   // Allocate important variables
   this->Impl->Bias.resize(noOfComponents, 0.0);
-  this->Impl->ScalarsRange.resize(noOfComponents);
-  for (int n = 0; n < noOfComponents; ++n)
-    {
-    this->Impl->ScalarsRange[n].resize(2, 0.0);
-    }
 
   // Set OpenGL states
   vtkVolumeStateRAII glState;
@@ -2961,13 +2993,10 @@ void vtkOpenGLGPUVolumeRayCastMapper::GPURender(vtkRenderer* ren,
   this->Impl->ShaderProgram->SetUniformf("in_sampleDistance",
                                          this->Impl->ActualSampleDistance);
 
-  double scalarRange[2];
-  for (int i = 0; i < 2; ++i)
-    {
-    scalarRange[i] = this->Impl->ScalarsRange[noOfComponents - 1][i];
-    }
-  vtkInternal::ToFloat(scalarRange, fvalue2);
-  this->Impl->ShaderProgram->SetUniform2fv("in_scalarsRange", 1, &fvalue2);
+  float scalarsRange[4][2];
+  vtkInternal::ToFloat(this->Impl->ScalarsRange, scalarsRange);
+  this->Impl->ShaderProgram->SetUniform2fv("in_scalarsRange", 4,
+                                           scalarsRange);
 
   // Bind textures
   this->Impl->VolumeTextureObject->Activate();
@@ -3157,6 +3186,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