ENH: Remove MapScalars() implementation

Commit a17fb31b15f4c344f1d253549468d250702196ef introduced opacity
mapping. Now that MapScalarsThroughTable2() is implemented, it will be
called from the vtkScalarsToColors base class. The overridded
MapScalars() method is no longer required.

Rendering/Core/Testing/Cxx/TestDiscretizableColorTransferFunctionStringArray.cxx

@@ -52,6 +52,8 @@ int TestDiscretizableColorTransferFunctionStringArray(int vtkNotUsed(argc), char
   tfer->SetAnnotation(category2, "Annotation2");
   tfer->SetAnnotation(category3, "Annotation3");
 
+  tfer->Build();
+
   vtkUnsignedCharArray* colors = tfer->MapScalars(sArray, VTK_RGBA, -1);
 
   unsigned char expectedColors[numStrings][4] = {

Rendering/Core/vtkDiscretizableColorTransferFunction.cxx

@@ -330,52 +330,6 @@ double vtkDiscretizableColorTransferFunction::GetOpacity(double v)
   return this->ScalarOpacityFunction->GetValue(v);
 }
 
-//-----------------------------------------------------------------------------
-vtkUnsignedCharArray* vtkDiscretizableColorTransferFunction::MapScalars(
-  vtkDataArray *scalars, int colorMode, int component)
-{
-  return this->MapScalars(static_cast<vtkAbstractArray*>(scalars), colorMode, component);
-}
-
-//-----------------------------------------------------------------------------
-vtkUnsignedCharArray* vtkDiscretizableColorTransferFunction::MapScalars(
-  vtkAbstractArray *scalars, int colorMode, int component)
-{
-  this->Build();
-
-  // if direct scalar mapping is enabled (and possible), the LUT is not used for
-  // color and we won't use it for opacity either.
-  bool direct_scalar_mapping =
-    ((colorMode == VTK_COLOR_MODE_DEFAULT &&
-      vtkArrayDownCast<vtkUnsignedCharArray>(scalars) != nullptr) ||
-     colorMode == VTK_COLOR_MODE_DIRECT_SCALARS);
-
-  vtkUnsignedCharArray *colors = (this->Discretize || this->IndexedLookup) ?
-    this->LookupTable->MapScalars(scalars, colorMode, component):
-    this->Superclass::MapScalars(scalars, colorMode, component);
-
-  // calculate alpha values
-  if (colors &&
-     (colors->GetNumberOfComponents() == 4) &&
-     (direct_scalar_mapping == false) &&
-     (this->IndexedLookup == false) && //  we don't change alpha for IndexedLookup.
-     (this->EnableOpacityMapping == true) &&
-     (this->ScalarOpacityFunction != nullptr))
-  {
-    // extract from docs from vtkScalarsToColors.h:
-    // "... When the component argument is -1,
-    //      then the this object uses its own selected technique to change a
-    //      vector into a scalar to map."
-    if (component < 0 && scalars->GetNumberOfComponents() > 1)
-    {
-      component = (this->VectorMode == vtkScalarsToColors::COMPONENT) ? this->VectorComponent : -1;
-    }
-    vtkDataArray* da = vtkArrayDownCast<vtkDataArray>(scalars);
-    this->MapDataArrayToOpacity(da, component, colors);
-  }
-  return colors;
-}
-
 //----------------------------------------------------------------------------
 // Internal mapping of the opacity value through the lookup table
 template <class T>
@@ -457,97 +411,6 @@ void vtkDiscretizableColorTransferFunction::MapScalarsThroughTable2(void *input,
   }
 }
 
-template<typename T>
-struct VectorComponentGetter
-{
-  double Get(
-    T* scalars, int component, int numberOfComponents, vtkIdType tuple)
-  {
-    double value = *(scalars + tuple * numberOfComponents + component);
-    return value;
-  }
-};
-
-template<typename T>
-struct VectorMagnitudeGetter
-{
-  double Get(
-    T* scalars, int component, int numberOfComponents, vtkIdType tuple)
-  {
-    (void)component;
-    double v = 0.0;
-    for (int j = 0; j < numberOfComponents; ++j)
-    {
-      double u = *(scalars + tuple * numberOfComponents + j);
-      v += u * u;
-    }
-    v = sqrt (v);
-    return v;
-  }
-};
-
-//-----------------------------------------------------------------------------
-template<typename T, typename VectorGetter>
-void vtkDiscretizableColorTransferFunction::MapVectorToOpacity (
-  VectorGetter getter, T* scalars, int component,
-  int numberOfComponents, vtkIdType numberOfTuples, unsigned char* colors)
-{
-  for(vtkIdType i = 0; i < numberOfTuples; i++)
-  {
-    double value = getter.Get (scalars, component, numberOfComponents, i);
-    double alpha = this->ScalarOpacityFunction->GetValue(value);
-    *(colors + i * 4 + 3) = static_cast<unsigned char>(alpha * 255.0 + 0.5);
-  }
-}
-
-//-----------------------------------------------------------------------------
-template<template<class> class VectorGetter>
-void vtkDiscretizableColorTransferFunction::AllTypesMapVectorToOpacity (
-  int scalarType,
-  void* scalarPtr, int component,
-  int numberOfComponents, vtkIdType numberOfTuples, unsigned char* colorPtr)
-{
-  switch (scalarType)
-  {
-    vtkTemplateAliasMacro(
-      MapVectorToOpacity(
-        VectorGetter<VTK_TT>(),
-        static_cast<VTK_TT*>(scalarPtr), component, numberOfComponents,
-        numberOfTuples, colorPtr));
-  }
-}
-
-//-----------------------------------------------------------------------------
-void vtkDiscretizableColorTransferFunction::MapDataArrayToOpacity(
-  vtkDataArray *scalars, int component, vtkUnsignedCharArray* colors)
-{
-  int scalarType = scalars->GetDataType ();
-  void* scalarPtr = scalars->GetVoidPointer(0);
-  unsigned char* colorPtr = static_cast<unsigned char*> (
-    colors->GetVoidPointer(0));
-  int numberOfComponents = scalars->GetNumberOfComponents ();
-  vtkIdType numberOfTuples = scalars->GetNumberOfTuples ();
-  if (component >= numberOfComponents)
-  {
-    vtkWarningMacro(
-      << "Clamping component: " << component
-      << " to numberOfComponents - 1: " << (numberOfComponents - 1));
-    component = numberOfComponents - 1;
-  }
-  if (component < 0)
-  {
-    AllTypesMapVectorToOpacity<VectorMagnitudeGetter> (
-      scalarType, scalarPtr,
-      component, numberOfComponents, numberOfTuples, colorPtr);
-  }
-  else
-  {
-    AllTypesMapVectorToOpacity<VectorComponentGetter> (
-      scalarType, scalarPtr,
-      component, numberOfComponents, numberOfTuples, colorPtr);
-  }
-}
-
 #ifndef VTK_LEGACY_REMOVE
 //-----------------------------------------------------------------------------
 double* vtkDiscretizableColorTransferFunction::GetRGBPoints()

Rendering/Core/vtkDiscretizableColorTransferFunction.h

@@ -157,31 +157,10 @@ public:
    */
   double GetOpacity(double v) override;
 
-  //@{
-  /**
-   * Internal methods that map a data array into a 4-component, unsigned char
-   * RGBA array. The color mode determines the behavior of mapping. If
-   * VTK_COLOR_MODE_DEFAULT is set, then unsigned char data arrays are
-   * treated as colors (and converted to RGBA if necessary); otherwise,
-   * the data is mapped through this instance of ScalarsToColors. The offset
-   * is used for data arrays with more than one component; it indicates
-   * which component to use to do the blending.
-   * When the component argument is -1, then the this object uses its
-   * own selected technique to change a vector into a scalar to map.
-
-   * When \a IndexedLookup (inherited from vtkScalarsToColors) is true,
-   * the scalar opacity function is not used regardless of
-   * \a EnableOpacityMapping.
-   */
-  vtkUnsignedCharArray *MapScalars(vtkDataArray *scalars, int colorMode,
-                                           int component) override;
-  vtkUnsignedCharArray *MapScalars(vtkAbstractArray *scalars, int colorMode,
-                                           int component) override;
-  //@}
-
   /**
    * Map a set of scalars through the lookup table.
-   * Overridden to map the opacity value.
+   * Overridden to map the opacity value. This internal method is inherited
+   * from vtkScalarsToColors and should never be called directly.
    */
   void MapScalarsThroughTable2(void *input, unsigned char *output,
     int inputDataType, int numberOfValues,