Added texture width checks in opacity and gradientOpacity tables.

ColorTransferFunction and PiecewiseFunction estimate an appropriate number of
samples based on a given range and minimum distance between nodes. This estimated
value is used by the volume lookup tables to sample the functions into the texture.

Author: alvarosan

Common/DataModel/vtkPiecewiseFunction.cxx

@@ -682,6 +682,37 @@ int vtkPiecewiseFunction::AdjustRange(double range[2])
   return 1;
 }
 
+//--------------------------------------------------------------------------
+int vtkPiecewiseFunction::EstimateMinNumberOfSamples(double const & x1,
+  double const & x2)
+{
+  double const d = this->FindMinimumXDistance();
+  int idealWidth = static_cast<int>(ceil((x2 - x1) / d));
+
+  return idealWidth;
+}
+
+//----------------------------------------------------------------------------
+double vtkPiecewiseFunction::FindMinimumXDistance()
+{
+  std::vector<vtkPiecewiseFunctionNode*> const & nodes = this->Internal->Nodes;
+  size_t const size = nodes.size();
+  if (size < 2)
+    return -1.0;
+
+  double distance = std::numeric_limits<double>::max();
+  for (size_t i = 0; i < size - 1; i++)
+    {
+    double const currentDist = nodes[i + 1]->X - nodes[i]->X;
+    if (currentDist < distance)
+      {
+      distance = currentDist;
+      }
+    }
+
+  return distance;
+}
+
 // Returns a table of function values evaluated at regular intervals
 void vtkPiecewiseFunction::GetTable( double xStart, double xEnd,
                                      int size, double* table,

Common/DataModel/vtkPiecewiseFunction.h

@@ -165,10 +165,26 @@ class VTKCOMMONDATAMODEL_EXPORT vtkPiecewiseFunction : public vtkDataObject
   vtkGetMacro(AllowDuplicateScalars, int);
   vtkBooleanMacro(AllowDuplicateScalars, int);
 
+  // Description:
+  // Estimates the minimum size of a table such that it would correctly sample this function.
+  // The returned value should be passed as parameter 'n' when calling GetTable().
+  int EstimateMinNumberOfSamples(double const & x1, double const & x2);
+
 protected:
   vtkPiecewiseFunction();
   ~vtkPiecewiseFunction();
 
+  // Internal method to sort the vector and update the
+  // Range whenever a node is added, edited or removed.
+  // It always calls Modified().
+  void SortAndUpdateRange();
+  // Returns true if the range has been updated and Modified() has been called
+  bool UpdateRange();
+
+  // Description:
+  // Traverses the nodes to find the minimum distance. Assumes nodes are sorted.
+  double FindMinimumXDistance();
+
   // The internal STL structures
   vtkPiecewiseFunctionInternals *Internal;
 
@@ -184,13 +200,6 @@ class VTKCOMMONDATAMODEL_EXPORT vtkPiecewiseFunction : public vtkDataObject
   // Min and max range of function point locations
   double Range[2];
 
-  // Internal method to sort the vector and update the
-  // Range whenever a node is added, edited or removed.
-  // It always calls Modified().
-  void SortAndUpdateRange();
-  // Returns true if the range has been updated and Modified() has been called
-  bool UpdateRange();
-
   int AllowDuplicateScalars;
 
 private:

Rendering/Core/vtkColorTransferFunction.cxx

@@ -1835,6 +1835,16 @@ int vtkColorTransferFunction::AdjustRange(double range[2])
   return 1;
 }
 
+//--------------------------------------------------------------------------
+int vtkColorTransferFunction::EstimateMinNumberOfSamples(double const & x1,
+  double const & x2)
+{
+  double const d = this->FindMinimumXDistance();
+  int idealWidth = static_cast<int>(ceil((x2 - x1) / d));
+
+  return idealWidth;
+}
+
 //----------------------------------------------------------------------------
 double vtkColorTransferFunction::FindMinimumXDistance()
 {
@@ -1844,11 +1854,9 @@ double vtkColorTransferFunction::FindMinimumXDistance()
     return -1.0;
 
   double distance = std::numeric_limits<double>::max();
-
   for (size_t i = 0; i < size - 1; i++)
     {
-    double const currentDist = nodes.at(i + 1)->X - nodes.at(i)->X;
-
+    double const currentDist = nodes[i + 1]->X - nodes[i]->X;
     if (currentDist < distance)
       {
       distance = currentDist;

Rendering/Core/vtkColorTransferFunction.h

@@ -247,8 +247,9 @@ class VTKRENDERINGCORE_EXPORT vtkColorTransferFunction : public vtkScalarsToColo
   virtual void GetIndexedColor(vtkIdType idx, double rgba[4]);
 
   // Description:
-  // Traverses the nodes to find the minimum distance. Assumes nodes are sorted.
-  double FindMinimumXDistance();
+  // Estimates the minimum size of a table such that it would correctly sample this function.
+  // The returned value should be passed as parameter 'n' when calling GetTable().
+  int EstimateMinNumberOfSamples(double const & x1, double const & x2);
 
 protected:
   vtkColorTransferFunction();
@@ -341,6 +342,10 @@ class VTKRENDERINGCORE_EXPORT vtkColorTransferFunction : public vtkScalarsToColo
   // any point existed at newX, it will also be removed.
   void MovePoint(double oldX, double newX);
 
+  // Description:
+  // Traverses the nodes to find the minimum distance. Assumes nodes are sorted.
+  double FindMinimumXDistance();
+
 private:
   vtkColorTransferFunction(const vtkColorTransferFunction&) VTK_DELETE_FUNCTION;
   void operator=(const vtkColorTransferFunction&) VTK_DELETE_FUNCTION;

Rendering/Volume/Testing/Cxx/TestGPURayCastLargeColorTransferFunction.cxx

@@ -18,6 +18,7 @@
 #include "vtkCamera.h"
 #include "vtkColorTransferFunction.h"
 #include "vtkGPUVolumeRayCastMapper.h"
+#include "vtkFixedPointVolumeRayCastMapper.h"
 #include "vtkImageData.h"
 #include "vtkLookupTable.h"
 #include "vtkPiecewiseFunction.h"
@@ -33,6 +34,9 @@
 #include "vtkVolumeProperty.h"
 #include "vtkXMLImageDataReader.h"
 
+
+#define GPU_MAPPER
+
 //----------------------------------------------------------------------------
 int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
 {
@@ -43,8 +47,16 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   // http://www.spl.harvard.edu/publications/item/view/2037
   vtkSmartPointer<vtkLookupTable> lut =
     vtkSmartPointer<vtkLookupTable>::New();
-  lut->SetNumberOfTableValues(5023);
-  lut->SetTableRange(0, 5022);
+
+  // Required for vtkLookupTable initialization
+  int const NumValues = 5023;
+  lut->SetNumberOfTableValues(NumValues);
+  lut->SetTableRange(0, NumValues-1);
+  for (int i = 0; i < NumValues; i++)
+    {
+    lut->SetTableValue(i, 0.0, 0.0, 0.0, 0.0);
+    }
+
   lut->SetTableValue(0, 0 / 255.0, 0 / 255.0, 0 / 255.0, 0 / 255.0);
   lut->SetTableValue(2, 250 / 255.0, 250 / 255.0, 225 / 255.0, 255 / 255.0);
   lut->SetTableValue(3, 225 / 255.0, 190 / 255.0, 150 / 255.0, 255 / 255.0);
@@ -80,7 +92,8 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   lut->SetTableValue(54, 98 / 255.0, 153 / 255.0, 112 / 255.0, 255 / 255.0);
   lut->SetTableValue(58, 165 / 255.0, 0 / 255.0, 255 / 255.0, 255 / 255.0);
   lut->SetTableValue(60, 165 / 255.0, 40 / 255.0, 40 / 255.0, 255 / 255.0);
-  lut->SetTableValue(61, 135 / 255.0, 205 / 255.0, 235 / 255.0, 255 / 255.0);
+//  lut->SetTableValue(61, 165 / 255.0, 40 / 255.0, 40 / 255.0, 255 / 255.0);
+  lut->SetTableValue(61, 135 / 255.0, 205 / 255.0, 235 / 255.0, 255 / 255.0); //medulla oblongata
   lut->SetTableValue(63, 90 / 255.0, 105 / 255.0, 215 / 255.0, 255 / 255.0);
   lut->SetTableValue(66, 0 / 255.0, 108 / 255.0, 112 / 255.0, 255 / 255.0);
   lut->SetTableValue(71, 0 / 255.0, 108 / 255.0, 112 / 255.0, 255 / 255.0);
@@ -393,6 +406,7 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   const double midPoint = 0.5;
   const double sharpness = 1.0;
   for (int i = 0; i < numColors; i++, value += step)
+//  for (int i = 0; i < numColors; i++, value += (50 * step) )
     {
     lut->GetTableValue(i, color);
 
@@ -412,16 +426,22 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   delete [] filename;
   filename = NULL;
 
+#ifdef GPU_MAPPER
   vtkSmartPointer<vtkGPUVolumeRayCastMapper> volumeMapper =
     vtkSmartPointer<vtkGPUVolumeRayCastMapper>::New();
+#else
+  vtkSmartPointer<vtkFixedPointVolumeRayCastMapper> volumeMapper =
+    vtkSmartPointer<vtkFixedPointVolumeRayCastMapper>::New();
+#endif
+
   volumeMapper->SetInputData(reader->GetOutput());
 
   vtkSmartPointer<vtkVolumeProperty> volumeProperty =
     vtkSmartPointer<vtkVolumeProperty>::New();
   volumeProperty->SetColor(colorTransferFunction);
   volumeProperty->SetScalarOpacity(opacity);
   volumeProperty->SetInterpolationTypeToNearest();
-  volumeProperty->ShadeOn();
+//  volumeProperty->ShadeOn();
   volumeProperty->SetAmbient(0.3);
   volumeProperty->SetDiffuse(0.6);
   volumeProperty->SetSpecular(0.5);
@@ -437,6 +457,7 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   xf->RotateZ(180.0);
   xf->RotateY(25.0);
   xf->RotateX(-65.0);
+  //xf->RotateY(-90.0);
   volume->SetUserTransform(xf);
 
   vtkSmartPointer<vtkRenderWindow> renderWindow =
@@ -460,7 +481,11 @@ int TestGPURayCastLargeColorTransferFunction(int argc, char* argv[])
   iren->SetRenderWindow(renderWindow);
   renderWindow->Render();// make sure we have an OpenGL context.
 
+#ifdef GPU_MAPPER
   int valid = volumeMapper->IsRenderSupported(renderWindow, volumeProperty);
+#else
+  int valid = 1;
+#endif
 
   int retVal;
   if (valid)