vtkScalarsToColors.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkScalarsToColors_h
#define vtkScalarsToColors_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkDeprecation.h"      // For VTK_DEPRECATED_IN_9_7_0
#include "vtkObject.h"
#include "vtkVariant.h"       // Set/get annotation methods require variants.
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkBitArray;
class vtkDataArray;
class vtkStringArray;
class vtkUnsignedCharArray;
 
class VTKCOMMONCORE_EXPORT VTK_MARSHALMANUAL vtkScalarsToColors : public vtkObject
{
public:
  vtkTypeMacro(vtkScalarsToColors, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkScalarsToColors* New();


  virtual vtkTypeBool IsOpaque();
  virtual vtkTypeBool IsOpaque(vtkAbstractArray* scalars, int colorMode, int vectorComponent);
  virtual vtkTypeBool IsOpaque(vtkAbstractArray* scalars, int colorMode, int vectorComponent,
    vtkUnsignedCharArray* ghosts, unsigned char ghostsToSkip = 0xff);

  virtual void Build() {}


  virtual double* GetRange() VTK_SIZEHINT(2);
  virtual void SetRange(double min, double max);
  virtual void SetRange(const double rng[2]) { this->SetRange(rng[0], rng[1]); }

  virtual const unsigned char* MapValue(double v);

  virtual void GetColor(double v, double rgb[3]);

  double* GetColor(double v) VTK_SIZEHINT(3)
  {
    this->GetColor(v, this->RGB);
    return this->RGB;
  }

  virtual double GetOpacity(double v);

  double GetLuminance(double x)
  {
    double rgb[3];
    this->GetColor(x, rgb);
    return rgb[0] * 0.30 + rgb[1] * 0.59 + rgb[2] * 0.11;
  }


  virtual void SetAlpha(double alpha);
  vtkGetMacro(Alpha, double);


  virtual VTK_NEWINSTANCE vtkUnsignedCharArray* MapScalars(
    vtkDataArray* scalars, int colorMode, int vectorComponent, int outputFormat = VTK_RGBA);
  virtual VTK_NEWINSTANCE vtkUnsignedCharArray* MapScalars(
    vtkAbstractArray* scalars, int colorMode, int vectorComponent, int outputFormat = VTK_RGBA);


  vtkSetMacro(VectorMode, int);
  vtkGetMacro(VectorMode, int);
  void SetVectorModeToMagnitude();
  void SetVectorModeToComponent();
  void SetVectorModeToRGBColors();
 
  enum VectorModes
  {
    MAGNITUDE = 0,
    COMPONENT = 1,
    RGBCOLORS = 2
  };


  vtkSetMacro(VectorComponent, int);
  vtkGetMacro(VectorComponent, int);


  vtkSetMacro(VectorSize, int);
  vtkGetMacro(VectorSize, int);


  void MapVectorsThroughTable(VTK_FUTURE_CONST void* input, unsigned char* output,
    int inputDataType, int numberOfTuples, int numberOfComponents, int outputFormat,
    int vectorComponent, int vectorSize);
  void MapVectorsThroughTable(VTK_FUTURE_CONST void* input, unsigned char* output,
    int inputDataType, int numberOfTuples, int numberOfComponents, int outputFormat)
  {
    this->MapVectorsThroughTable(
      input, output, inputDataType, numberOfTuples, numberOfComponents, outputFormat, -1, -1);
  }
  void MapVectorsThroughTable(vtkDataArray* input, unsigned char* output, int numberOfTuples,
    int numberOfComponents, int vectorComponent, int vectorSize, int outputFormat);
  void MapVectorsThroughTable(vtkDataArray* input, unsigned char* output, int numberOfTuples,
    int numberOfComponents, int outputFormat)
  {
    this->MapVectorsThroughTable(
      input, output, numberOfTuples, numberOfComponents, -1, -1, outputFormat);
  }



  void MapScalarsThroughTable(vtkDataArray* scalars, unsigned char* output, int outputFormat);
  void MapScalarsThroughTable(vtkDataArray* scalars, unsigned char* output)
  {
    this->MapScalarsThroughTable(scalars, output, VTK_RGBA);
  }



  virtual void MapScalarsThroughTable(vtkAbstractArray* input, unsigned char* output,
    int numberOfTuples, int numberOfComponents, int vectorComponent, int outputFormat);
  void MapScalarsThroughTable(VTK_FUTURE_CONST void* input, unsigned char* output,
    int inputDataType, int numberOfTuples, int numberOfComponents, int outputFormat);
  VTK_DEPRECATED_IN_9_7_0("Use the MapScalarsThroughTable overload instead")
  virtual void MapScalarsThroughTable2(VTK_FUTURE_CONST void* input, unsigned char* output,
    int inputDataType, int numberOfTuples, int numberOfComponents, int outputFormat);

  virtual void DeepCopy(vtkScalarsToColors* o);

  virtual vtkTypeBool UsingLogScale() { return 0; }

  virtual vtkIdType GetNumberOfAvailableColors();


  virtual void SetAnnotations(vtkAbstractArray* values, vtkStringArray* annotations);
  vtkGetObjectMacro(AnnotatedValues, vtkAbstractArray);
  vtkGetObjectMacro(Annotations, vtkStringArray);

  virtual vtkIdType SetAnnotation(vtkVariant value, vtkStdString annotation);

  virtual vtkIdType SetAnnotation(vtkStdString value, vtkStdString annotation);

  vtkIdType GetNumberOfAnnotatedValues();

  vtkVariant GetAnnotatedValue(vtkIdType idx);

  vtkStdString GetAnnotation(vtkIdType idx);

  virtual void GetAnnotationColor(const vtkVariant& val, double rgba[4]);

  vtkIdType GetAnnotatedValueIndex(vtkVariant val);

  vtkIdType GetAnnotatedValueIndexInternal(const vtkVariant& val);

  virtual void GetIndexedColor(vtkIdType i, double rgba[4]);

  virtual bool RemoveAnnotation(vtkVariant value);

  virtual void ResetAnnotations();


  vtkSetMacro(IndexedLookup, vtkTypeBool);
  vtkGetMacro(IndexedLookup, vtkTypeBool);
  vtkBooleanMacro(IndexedLookup, vtkTypeBool);


  template <typename T>
  static unsigned char ColorToUChar(T t)
  {
    return static_cast<unsigned char>(t);
  }
  template <typename T>
  static void ColorToUChar(T t, unsigned char* dest)
  {
    *dest = ColorToUChar(t);
  }

 
protected:
  vtkScalarsToColors();
  ~vtkScalarsToColors() override;

  static vtkSmartPointer<vtkUnsignedCharArray> UnpackBits(
    vtkBitArray* colors, int numComp, vtkIdType numTuples);


  VTK_DEPRECATED_IN_9_7_0("Use the overload taking vtkDataArray* instead")
  void MapColorsToColors(VTK_FUTURE_CONST void* input, unsigned char* output, int inputDataType,
    int numberOfTuples, int numberOfComponents, int vectorSize, int outputFormat);
  void MapColorsToColors(vtkDataArray* input, unsigned char* output, int numberOfTuples,
    int numberOfComponents, int vectorComponent, int vectorSize, int outputFormat);

  VTK_NEWINSTANCE vtkUnsignedCharArray* ConvertToRGBA(
    vtkDataArray* colors, int numComp, int numTuples);


  VTK_DEPRECATED_IN_9_7_0("Use the overload taking vtkDataArray* instead")
  void MapVectorsToMagnitude(VTK_FUTURE_CONST void* input, double* output, int inputDataType,
    int numberOfTuples, int numberOfComponents, int vectorSize);
  void MapVectorsToMagnitude(vtkDataArray* input, double* output, int numberOfTuples,
    int numberOfComponents, int vectorComponent, int vectorSize);

  virtual vtkIdType CheckForAnnotatedValue(vtkVariant value);

  virtual void UpdateAnnotatedValueMap();
 
  // Annotations of specific values.
  vtkAbstractArray* AnnotatedValues;
  vtkStringArray* Annotations;
 
  class vtkInternalAnnotatedValueList;
  vtkInternalAnnotatedValueList* AnnotatedValueList;
 
  vtkTypeBool IndexedLookup;
 
  double Alpha;
 
  // How to map arrays with multiple components.
  int VectorMode;
  int VectorComponent;
  int VectorSize;
 
  unsigned char RGBABytes[4];
 
private:
  double RGB[3];
  double InputRange[2];
 
  vtkScalarsToColors(const vtkScalarsToColors&) = delete;
  void operator=(const vtkScalarsToColors&) = delete;
};


template <>
inline unsigned char vtkScalarsToColors::ColorToUChar(double t)
{
  double temp = (t * 255.0) + 0.5;
  return static_cast<unsigned char>(temp);
}
template <>
inline unsigned char vtkScalarsToColors::ColorToUChar(float t)
{
  double temp = (t * 255.0) + 0.5;
  return static_cast<unsigned char>(temp);
}

 
VTK_ABI_NAMESPACE_END
#endif