vtkColorTransferFunction.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 vtkColorTransferFunction_h
#define vtkColorTransferFunction_h

#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkScalarsToColors.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL

VTK_ABI_NAMESPACE_BEGIN
class vtkColorTransferFunctionInternals;
class vtkDoubleArray;

#define VTK_CTF_RGB 0
#define VTK_CTF_HSV 1
#define VTK_CTF_LAB 2
#define VTK_CTF_DIVERGING 3
#define VTK_CTF_LAB_CIEDE2000 4
#define VTK_CTF_STEP 5
#define VTK_CTF_PROLAB 6

#define VTK_CTF_LINEAR 0
#define VTK_CTF_LOG10 1

class VTKRENDERINGCORE_EXPORT VTK_MARSHALMANUAL vtkColorTransferFunction : public vtkScalarsToColors
{
public:
  static vtkColorTransferFunction* New();
  vtkTypeMacro(vtkColorTransferFunction, vtkScalarsToColors);
  void DeepCopy(vtkScalarsToColors* f) override;
  void ShallowCopy(vtkColorTransferFunction* f);

  void PrintSelf(ostream& os, vtkIndent indent) override;

  int GetSize();


  int AddRGBPoint(double x, double r, double g, double b);
  int AddRGBPoint(double x, double r, double g, double b, double midpoint, double sharpness);
  int AddRGBPoints(vtkDoubleArray* x, vtkDoubleArray* rgbColors);
  int AddRGBPoints(vtkDoubleArray* x, vtkDoubleArray* rgbColors, double midpoint, double sharpness);
  int AddHSVPoint(double x, double h, double s, double v);
  int AddHSVPoint(double x, double h, double s, double v, double midpoint, double sharpness);
  int RemovePoint(double x);


  void AddRGBSegment(
    double x1, double r1, double g1, double b1, double x2, double r2, double g2, double b2);
  void AddHSVSegment(
    double x1, double h1, double s1, double v1, double x2, double h2, double s2, double v2);

  void RemoveAllPoints();

  double* GetColor(double x) VTK_SIZEHINT(3) { return vtkScalarsToColors::GetColor(x); }
  void GetColor(double x, double rgb[3]) override;


  double GetRedValue(double x);
  double GetGreenValue(double x);
  double GetBlueValue(double x);


  int GetNodeValue(int index, double val[6]);
  int SetNodeValue(int index, double val[6]);

  const unsigned char* MapValue(double v) override;


  double* GetRange() VTK_SIZEHINT(2) override { return this->Range; }
  virtual void GetRange(double& arg1, double& arg2)
  {
    arg1 = this->Range[0];
    arg2 = this->Range[1];
  }
  virtual void GetRange(double _arg[2]) { this->GetRange(_arg[0], _arg[1]); }

  int AdjustRange(double range[2]);


  void GetTable(double x1, double x2, int n, double* table);
  void GetTable(double x1, double x2, int n, float* table);
  const unsigned char* GetTable(double x1, double x2, int n);

  void BuildFunctionFromTable(double x1, double x2, int size, double* table);


  vtkSetClampMacro(Clamping, vtkTypeBool, 0, 1);
  vtkGetMacro(Clamping, vtkTypeBool);
  vtkBooleanMacro(Clamping, vtkTypeBool);


  vtkSetClampMacro(ColorSpace, int, VTK_CTF_RGB, VTK_CTF_PROLAB);
  void SetColorSpaceToRGB() { this->SetColorSpace(VTK_CTF_RGB); }
  void SetColorSpaceToHSV() { this->SetColorSpace(VTK_CTF_HSV); }
  void SetColorSpaceToLab() { this->SetColorSpace(VTK_CTF_LAB); }
  void SetColorSpaceToLabCIEDE2000() { this->SetColorSpace(VTK_CTF_LAB_CIEDE2000); }
  void SetColorSpaceToDiverging() { this->SetColorSpace(VTK_CTF_DIVERGING); }
  void SetColorSpaceToStep() { this->SetColorSpace(VTK_CTF_STEP); }
  void SetColorSpaceToProlab() { this->SetColorSpace(VTK_CTF_PROLAB); };
  vtkGetMacro(ColorSpace, int);
  vtkSetMacro(HSVWrap, vtkTypeBool);
  vtkGetMacro(HSVWrap, vtkTypeBool);
  vtkBooleanMacro(HSVWrap, vtkTypeBool);


  vtkSetMacro(Scale, int);
  void SetScaleToLinear() { this->SetScale(VTK_CTF_LINEAR); }
  void SetScaleToLog10() { this->SetScale(VTK_CTF_LOG10); }
  vtkGetMacro(Scale, int);


  vtkSetVector3Macro(NanColor, double);
  vtkGetVector3Macro(NanColor, double);


  vtkSetMacro(NanOpacity, double);
  vtkGetMacro(NanOpacity, double);


  virtual void SetNanColorRGBA(double r, double g, double b, double a)
  {
    this->SetNanColor(r, g, b);
    this->SetNanOpacity(a);
  }

  void SetNanColorRGBA(double rgba[4])
  {
    this->SetNanColorRGBA(rgba[0], rgba[1], rgba[2], rgba[3]);
  }


  vtkSetVector3Macro(BelowRangeColor, double);
  vtkGetVector3Macro(BelowRangeColor, double);


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


  vtkSetVector3Macro(AboveRangeColor, double);
  vtkGetVector3Macro(AboveRangeColor, double);


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

  double* GetDataPointer();

  void FillFromDataPointer(int n, double* ptr);


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


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

  vtkIdType GetNumberOfAvailableColors() override;

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

  int EstimateMinNumberOfSamples(double const& x1, double const& x2);

protected:
  vtkColorTransferFunction();
  ~vtkColorTransferFunction() override;

  vtkColorTransferFunctionInternals* Internal;

  vtkTypeBool Clamping;

  int ColorSpace;

  vtkTypeBool HSVWrap;

  int Scale;

  double NanColor[3];

  double NanOpacity;

  double BelowRangeColor[3];

  vtkTypeBool UseBelowRangeColor;

  double AboveRangeColor[3];

  vtkTypeBool UseAboveRangeColor;

  double* Function;

  double Range[2];

  unsigned char UnsignedCharRGBAValue[4];

  vtkTypeBool AllowDuplicateScalars;

  vtkTimeStamp BuildTime;
  unsigned char* Table;

  int TableSize;


  void SetRange(double, double) override {}
  void SetRange(const double rng[2]) override { this->SetRange(rng[0], rng[1]); }

  void SortAndUpdateRange();

  bool UpdateRange();

  void MovePoint(double oldX, double newX);

  double FindMinimumXDistance();

private:
  vtkColorTransferFunction(const vtkColorTransferFunction&) = delete;
  void operator=(const vtkColorTransferFunction&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif