vtkDiscretizableColorTransferFunction.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 vtkDiscretizableColorTransferFunction_h
#define vtkDiscretizableColorTransferFunction_h
 
#include "vtkColorTransferFunction.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // for vtkSmartPointer
#include "vtkWrappingHints.h"       // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkColorTransferFunction;
class vtkLookupTable;
class vtkPiecewiseFunction;
class vtkUnsignedCharArray;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALMANUAL vtkDiscretizableColorTransferFunction
  : public vtkColorTransferFunction
{
public:
  static vtkDiscretizableColorTransferFunction* New();
  vtkTypeMacro(vtkDiscretizableColorTransferFunction, vtkColorTransferFunction);
  void PrintSelf(ostream& os, vtkIndent indent) override;


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

  void SetIndexedColorRGB(unsigned int index, const double rgb[3])
  {
    this->SetIndexedColor(index, rgb[0], rgb[1], rgb[2]);
  }
  void SetIndexedColorRGBA(unsigned int index, const double rgba[4])
  {
    this->SetIndexedColor(index, rgba[0], rgba[1], rgba[2], rgba[3]);
  }
  void SetIndexedColor(unsigned int index, double r, double g, double b, double a = 1.0);

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


  void SetNumberOfIndexedColors(unsigned int count);
  unsigned int GetNumberOfIndexedColors();

  void Build() override;


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


  virtual void SetUseLogScale(vtkTypeBool useLogScale);
  vtkGetMacro(UseLogScale, vtkTypeBool);


  vtkSetMacro(NumberOfValues, vtkIdType);
  vtkGetMacro(NumberOfValues, vtkIdType);

  const unsigned char* MapValue(double v) override;

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

  double GetOpacity(double v) override;


  void MapScalarsThroughTable(vtkAbstractArray* input, unsigned char* output, int numberOfTuples,
    int numberOfComponents, int vectorComponent, int outputFormat) override;
  using vtkScalarsToColors::MapScalarsThroughTable;

  void SetAlpha(double alpha) override;


  void SetNanColor(double r, double g, double b) override;
  void SetNanColor(const double rgb[3]) override { this->SetNanColor(rgb[0], rgb[1], rgb[2]); }

  void SetNanOpacity(double a) override;

  vtkTypeBool UsingLogScale() override { return this->UseLogScale; }

  vtkIdType GetNumberOfAvailableColors() override;


  virtual void SetScalarOpacityFunction(vtkPiecewiseFunction* function);
  virtual vtkPiecewiseFunction* GetScalarOpacityFunction() const;


  vtkSetMacro(EnableOpacityMapping, bool);
  vtkGetMacro(EnableOpacityMapping, bool);
  vtkBooleanMacro(EnableOpacityMapping, bool);

  vtkMTimeType GetMTime() override;
 
protected:
  vtkDiscretizableColorTransferFunction();
  ~vtkDiscretizableColorTransferFunction() override;

  vtkTypeBool Discretize;

  vtkTypeBool UseLogScale;

  vtkIdType NumberOfValues;

  vtkLookupTable* LookupTable;
 
  vtkTimeStamp LookupTableUpdateTime;
 
  bool EnableOpacityMapping;
  vtkSmartPointer<vtkPiecewiseFunction> ScalarOpacityFunction;
 
  void MapDataArrayToOpacity(vtkDataArray* scalars, int component, vtkUnsignedCharArray* colors);
 
private:
  vtkDiscretizableColorTransferFunction(const vtkDiscretizableColorTransferFunction&) = delete;
  void operator=(const vtkDiscretizableColorTransferFunction&) = delete;
 
  template <typename T, typename VectorGetter>
  void MapVectorToOpacity(VectorGetter getter, T* scalars, int component, int numberOfComponents,
    vtkIdType numberOfTuples, unsigned char* colors);
 
  template <template <class> class VectorGetter>
  void AllTypesMapVectorToOpacity(int scalarType, void* scalarsPtr, int component,
    int numberOfComponents, vtkIdType numberOfTuples, unsigned char* colors);
 
  class vtkInternals;
  vtkInternals* Internals;
};
 
VTK_ABI_NAMESPACE_END
#endif