BUG:Fixed a problem with volume rendering with non-active scalars

Needed to add compute increment methods that don't assume an active
scalar field has been set.

Change-Id: I911f5d1a8a834ba1bcd48c57c6b777bd56126888

Filtering/vtkImageData.cxx

@@ -1210,7 +1210,7 @@ void vtkImageData::SetNumberOfScalarComponents(int num)
     vtkErrorMacro("SetNumberOfScalarComponents called with no "
                   "executive producing this image data object.");
     }
-  this->ComputeIncrements();
+  this->ComputeIncrements(num);
 }
 
 //----------------------------------------------------------------------------
@@ -1239,6 +1239,16 @@ vtkIdType *vtkImageData::GetIncrements()
   return this->Increments;
 }
 
+//----------------------------------------------------------------------------
+vtkIdType *vtkImageData::GetIncrements(vtkDataArray *scalars)
+{
+  // Make sure the increments are up to date. The filter bypass and update
+  // mechanism make it tricky to update the increments anywhere other than here
+  this->ComputeIncrements(scalars);
+
+  return this->Increments;
+}
+
 //----------------------------------------------------------------------------
 void vtkImageData::GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
 {
@@ -1249,6 +1259,17 @@ void vtkImageData::GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &in
   incZ = inc[2];
 }
 
+//----------------------------------------------------------------------------
+void vtkImageData::GetIncrements(vtkDataArray *scalars,
+                                 vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
+{
+  vtkIdType inc[3];
+  this->ComputeIncrements(scalars, inc);
+  incX = inc[0];
+  incY = inc[1];
+  incZ = inc[2];
+}
+
 //----------------------------------------------------------------------------
 void vtkImageData::GetIncrements(vtkIdType inc[3])
 {
@@ -1256,9 +1277,24 @@ void vtkImageData::GetIncrements(vtkIdType inc[3])
 }
 
 
+//----------------------------------------------------------------------------
+void vtkImageData::GetIncrements(vtkDataArray *scalars, vtkIdType inc[3])
+{
+  this->ComputeIncrements(inc);
+}
+
+
 //----------------------------------------------------------------------------
 void vtkImageData::GetContinuousIncrements(int extent[6], vtkIdType &incX,
                                            vtkIdType &incY, vtkIdType &incZ)
+{
+  this->GetContinuousIncrements(this->GetPointData()->GetScalars(),
+                                extent, incX, incY, incZ);
+}
+//----------------------------------------------------------------------------
+void vtkImageData::GetContinuousIncrements(vtkDataArray *scalars,
+                                           int extent[6], vtkIdType &incX,
+                                           vtkIdType &incY, vtkIdType &incZ)
 {
   int e0, e1, e2, e3;
 
@@ -1288,7 +1324,7 @@ void vtkImageData::GetContinuousIncrements(int extent[6], vtkIdType &incX,
 
   // Make sure the increments are up to date
   vtkIdType inc[3];
-  this->ComputeIncrements(inc);
+  this->ComputeIncrements(scalars, inc);
 
   incY = inc[1] - (e1 - e0 + 1)*inc[0];
   incZ = inc[2] - (e3 - e2 + 1)*inc[1];
@@ -1297,15 +1333,32 @@ void vtkImageData::GetContinuousIncrements(int extent[6], vtkIdType &incX,
 
 //----------------------------------------------------------------------------
 // This method computes the increments from the MemoryOrder and the extent.
+// This version assumes we are using the Active Scalars
 void vtkImageData::ComputeIncrements(vtkIdType inc[3])
 {
-  int idx;
-  // make sure we have data before computing incrments to traverse it
-  if (!this->GetPointData()->GetScalars())
+  this->ComputeIncrements(this->GetPointData()->GetScalars(), inc);
+}
+
+//----------------------------------------------------------------------------
+// This method computes the increments from the MemoryOrder and the extent.
+void vtkImageData::ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3])
+{
+  if (!scalars)
     {
-    return;
+    vtkErrorMacro("No Scalar Field has been specified - assuming 1 component!");
+    this->ComputeIncrements(1, inc);
+    }
+  else
+    {
+    this->ComputeIncrements(scalars->GetNumberOfComponents(), inc);
     }
-  vtkIdType incr = this->GetPointData()->GetScalars()->GetNumberOfComponents();
+}
+//----------------------------------------------------------------------------
+// This method computes the increments from the MemoryOrder and the extent.
+void vtkImageData::ComputeIncrements(int numberOfComponents, vtkIdType inc[3])
+{
+  int idx;
+  vtkIdType incr = numberOfComponents;
   const int* extent = this->Extent;
 
   for (idx = 0; idx < 3; ++idx)

Filtering/vtkImageData.h

@@ -189,10 +189,15 @@ public:
   // Description:
   // Different ways to get the increments for moving around the data.
   // GetIncrements() calls ComputeIncrements() to ensure the increments are
-  // up to date.
+  // up to date.  The first three methods compute the increments based on the
+  // active scalar field while the next three, the scalar field is passed in.
   virtual vtkIdType *GetIncrements();
   virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
   virtual void GetIncrements(vtkIdType inc[3]);
+  virtual vtkIdType *GetIncrements(vtkDataArray *scalars);
+  virtual void GetIncrements(vtkDataArray *scalars, 
+                             vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
+  virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
 
   // Description:
   // Different ways to get the increments for moving around the data.
@@ -204,8 +209,12 @@ public:
   // over Z, Y, X, C, incrementing the pointer by 1 after each
   // component.  When the end of the component is reached, the pointer
   // is set to the beginning of the next pixel, thus incX is properly set to 0.
+  // The first form of GetContinuousIncrements uses the active scalar field
+  // while the second form allows the scalar array to be passed in.
   virtual void GetContinuousIncrements(
     int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
+  virtual void GetContinuousIncrements(vtkDataArray *scalars,
+    int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
 
   // Description:
   // Access the native pointer for the scalar data
@@ -376,8 +385,19 @@ protected:
 
   int Extent[6];
 
+  // The first method assumes Active Scalars
   void ComputeIncrements();
+  // This one is given the number of components of the
+  // scalar field explicitly
+  void ComputeIncrements(int numberOfComponents);
+  void ComputeIncrements(vtkDataArray *scalars);
+
+  // The first method assumes Acitive Scalars
   void ComputeIncrements(vtkIdType inc[3]);
+  // This one is given the number of components of the
+  // scalar field explicitly
+  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
+  void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
   void CopyOriginAndSpacingFromPipeline();
 
   vtkTimeStamp ExtentComputeTime;
@@ -412,6 +432,18 @@ inline void vtkImageData::ComputeIncrements()
   this->ComputeIncrements(this->Increments);
 }
 
+//----------------------------------------------------------------------------
+inline void vtkImageData::ComputeIncrements(int numberOfComponents)
+{
+  this->ComputeIncrements(numberOfComponents, this->Increments);
+}
+
+//----------------------------------------------------------------------------
+inline void vtkImageData::ComputeIncrements(vtkDataArray *scalars)
+{
+  this->ComputeIncrements(scalars, this->Increments);
+}
+
 //----------------------------------------------------------------------------
 inline void vtkImageData::GetPoint(vtkIdType id, double x[3])
 {

VolumeRendering/vtkVolumeRayCastSpaceLeapingImageFilter.cxx

@@ -143,8 +143,10 @@ void vtkVolumeRayCastSpaceLeapingImageFilter
 
 //----------------------------------------------------------------------------
 void
-vtkVolumeRayCastSpaceLeapingImageFilterClearOutput(
-  vtkImageData *outData, int outExt[6], unsigned int nComponents )
+vtkVolumeRayCastSpaceLeapingImageFilterClearOutput(vtkDataArray *scalars,
+                                                   vtkImageData *outData,
+                                                   int outExt[6],
+                                                   unsigned int nComponents )
 {
   unsigned short *tmpPtr = static_cast< unsigned short * >(
                 outData->GetScalarPointerForExtent(outExt));
@@ -152,7 +154,8 @@ vtkVolumeRayCastSpaceLeapingImageFilterClearOutput(
   // Get increments to march through the thread's output extents
 
   vtkIdType outInc0, outInc1, outInc2;
-  outData->GetContinuousIncrements(outExt, outInc0, outInc1, outInc2);
+  outData->GetContinuousIncrements(scalars,
+                                   outExt, outInc0, outInc1, outInc2);
 
   // A. Initialize the arrays with a blank flag.
 
@@ -243,7 +246,8 @@ vtkVolumeRayCastSpaceLeapingImageFilterMinMaxExecute(
   // B.2 Get increments to march through the input extents
 
   vtkIdType inInc0, inInc1, inInc2;
-  inData->GetContinuousIncrements(inExt, inInc0, inInc1, inInc2);
+  inData->GetContinuousIncrements(scalars,
+                                  inExt, inInc0, inInc1, inInc2);
 
   // Get increments to march through the output extents
 
@@ -394,7 +398,8 @@ vtkVolumeRayCastSpaceLeapingImageFilterMaxGradientMagnitudeExecute(
   // B.2 Get increments to march through the input extents
 
   vtkIdType inInc0, inInc1, inInc2;
-  inData->GetContinuousIncrements(inExt, inInc0, inInc1, inInc2);
+  inData->GetContinuousIncrements(self->GetCurrentScalars(),
+                                  inExt, inInc0, inInc1, inInc2);
 
   // Get increments to march through the output extents
 
@@ -543,7 +548,8 @@ vtkVolumeRayCastSpaceLeapingImageFilterMinMaxAndMaxGradientMagnitudeExecute(
   // B.2 Get increments to march through the input extents
 
   vtkIdType inInc0, inInc1, inInc2;
-  inData->GetContinuousIncrements(inExt, inInc0, inInc1, inInc2);
+  inData->GetContinuousIncrements(scalars,
+                                  inExt, inInc0, inInc1, inInc2);
 
   // Get increments to march through the output extents
 
@@ -682,7 +688,8 @@ void vtkVolumeRayCastSpaceLeapingImageFilter
   // Get increments to march through the output
 
   vtkIdType outInc0, outInc1, outInc2;
-  outData->GetContinuousIncrements(outExt, outInc0, outInc1, outInc2);
+  outData->GetContinuousIncrements(this->CurrentScalars,
+                                   outExt, outInc0, outInc1, outInc2);
 
   // Now process the flags
 
@@ -769,7 +776,8 @@ void vtkVolumeRayCastSpaceLeapingImageFilter
   // Get increments to march through the output
 
   vtkIdType outInc0, outInc1, outInc2;
-  outData->GetContinuousIncrements(outExt, outInc0, outInc1, outInc2);
+  outData->GetContinuousIncrements(this->CurrentScalars,
+                                   outExt, outInc0, outInc1, outInc2);
 
   // Now process the flags
 
@@ -870,8 +878,8 @@ void vtkVolumeRayCastSpaceLeapingImageFilter::ThreadedRequestData(
 
   if (this->ComputeMinMax)
     {
-    vtkVolumeRayCastSpaceLeapingImageFilterClearOutput(
-                        outData[0], outExt, nComponents );
+    vtkVolumeRayCastSpaceLeapingImageFilterClearOutput(this->CurrentScalars,
+                                                       outData[0], outExt, nComponents );
     }