vtkColorTransferFunction.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkColorTransferFunction.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkColorTransferFunction_h
#define vtkColorTransferFunction_h
 
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkScalarsToColors.h"
 
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_LINEAR 0
#define VTK_CTF_LOG10 1
 
class VTKRENDERINGCORE_EXPORT 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_STEP);
  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); }
  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 MapScalarsThroughTable2(void* input, unsigned char* output, int inputDataType,
    int numberOfValues, int inputIncrement, int outputIncrement) override;
 
 
  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;
};
 
#endif