vtkPiecewiseFunction.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 vtkPiecewiseFunction_h
#define vtkPiecewiseFunction_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkPiecewiseFunctionInternals;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkPiecewiseFunction : public vtkDataObject
{
public:
  static vtkPiecewiseFunction* New();
  vtkTypeMacro(vtkPiecewiseFunction, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void DeepCopy(vtkDataObject* f) override;
  void ShallowCopy(vtkDataObject* f) override;
 
  enum SearchMethod
  {
    BINARY_SEARCH = 0,
    INTERPOLATION_SEARCH = 1,
    MAX_ENUM = 2
  };
 
  int GetDataObjectType() override { return VTK_PIECEWISE_FUNCTION; }
 
  int GetSize();
 
 
  int AddPoint(double x, double y);
  int AddPoint(double x, double y, double midpoint, double sharpness);
 
  bool RemovePointByIndex(size_t id);
 
  int RemovePoint(double x);
 
  int RemovePoint(double x, double y);
 
  void RemoveAllPoints();
 
  void AddSegment(double x1, double y1, double x2, double y2);
 
  double GetValue(double x);
 
 
  int GetNodeValue(int index, double val[4]);
  int SetNodeValue(int index, double val[4]);
 
 
  double* GetDataPointer();
  void FillFromDataPointer(int, double*);
 
 
  vtkGetVector2Macro(Range, double);
 
  int AdjustRange(double range[2]);
 
 
  void GetTable(double x1, double x2, int size, float* table, int stride = 1, int logIncrements = 0,
    double epsilon = 1e-5);
  void GetTable(double x1, double x2, int size, double* table, int stride = 1,
    int logIncrements = 0, double epsilon = 1e-5);
 
  void BuildFunctionFromTable(double x1, double x2, int size, double* table, int stride = 1);
 
 
  vtkSetMacro(Clamping, vtkTypeBool);
  vtkGetMacro(Clamping, vtkTypeBool);
  vtkBooleanMacro(Clamping, vtkTypeBool);
 
  vtkSetMacro(UseLogScale, bool);
  vtkGetMacro(UseLogScale, bool);
  vtkBooleanMacro(UseLogScale, bool);
  const char* GetType();
 
  double GetFirstNonZeroValue();
 
  void Initialize() override;
 
 
  static vtkPiecewiseFunction* GetData(vtkInformation* info);
  static vtkPiecewiseFunction* GetData(vtkInformationVector* v, int i = 0);
 
 
  vtkSetMacro(AllowDuplicateScalars, vtkTypeBool);
  vtkGetMacro(AllowDuplicateScalars, vtkTypeBool);
  vtkBooleanMacro(AllowDuplicateScalars, vtkTypeBool);
 
  int EstimateMinNumberOfSamples(double const& x1, double const& x2);
 
  void UpdateSearchMethod(double epsilon = 1e-12, double thresh = 1e-4);
 
 
  int GetAutomaticSearchMethod();
  void SetUseCustomSearchMethod(bool use);
  void SetCustomSearchMethod(int type);
  int GetCustomSearchMethod();
 
protected:
  vtkPiecewiseFunction();
  ~vtkPiecewiseFunction() override;
 
  void SortAndUpdateRange(bool updateSearchMethod = true);
 
  bool UpdateRange();
 
  double FindMinimumXDistance();
 
  // The internal STL structures
  vtkPiecewiseFunctionInternals* Internal;
 
  // Determines the function value outside of defined points
  // Zero = always return 0.0 outside of defined points
  // One  = clamp to the lowest value below defined points and
  //        highest value above defined points
  vtkTypeBool Clamping;
 
  // Array of points ((X,Y) pairs)
  double* Function;
 
  // Min and max range of function point locations
  double Range[2];
 
  vtkTypeBool AllowDuplicateScalars;
 
  bool UseLogScale;
 
private:
  vtkPiecewiseFunction(const vtkPiecewiseFunction&) = delete;
  void operator=(const vtkPiecewiseFunction&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif