vtkPiecewiseFunction.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkPiecewiseFunction.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 vtkPiecewiseFunction_h
#define vtkPiecewiseFunction_h

#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"

class vtkPiecewiseFunctionInternals;

class VTKCOMMONDATAMODEL_EXPORT 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;

  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 );
  int RemovePoint( double x );

  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 );
  void GetTable( double x1, double x2, int size, double *table, int stride=1, int logIncrements=0 );

  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);

protected:
  vtkPiecewiseFunction();
  ~vtkPiecewiseFunction() override;

  // Internal method to sort the vector and update the
  // Range whenever a node is added, edited or removed.
  // It always calls Modified().
  void SortAndUpdateRange();
  // Returns true if the range has been updated and Modified() has been called
  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;
};

#endif