vtkExprTkFunctionParser.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkExprTkFunctionParser.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 vtkExprTkFunctionParser_h
#define vtkExprTkFunctionParser_h
 
#include "vtkCommonMiscModule.h" // For export macro
#include "vtkObject.h"
#include "vtkTuple.h" // needed for vtkTuple
#include <string>     // needed for string.
#include <vector>     // needed for vector
 
// forward declarations for ExprTk tools
struct vtkExprTkTools;
 
class VTKCOMMONMISC_EXPORT vtkExprTkFunctionParser : public vtkObject
{
public:
  static vtkExprTkFunctionParser* New();
  vtkTypeMacro(vtkExprTkFunctionParser, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMTimeType GetMTime() override;
 
 
  void SetFunction(const char* function);
  const char* GetFunction() { return this->Function.c_str(); }
 
  int IsScalarResult();
 
  int IsVectorResult();
 
  double GetScalarResult();
 
 
  double* GetVectorResult() VTK_SIZEHINT(3);
  void GetVectorResult(double result[3])
  {
    double* r = this->GetVectorResult();
    result[0] = r[0];
    result[1] = r[1];
    result[2] = r[2];
  }
 
 
  void SetScalarVariableValue(const std::string& variableName, double value);
  void SetScalarVariableValue(int i, double value);
 
 
  double GetScalarVariableValue(const std::string& variableName);
  double GetScalarVariableValue(int i);
 
 
  void SetVectorVariableValue(
    const std::string& variableName, double xValue, double yValue, double zValue);
  void SetVectorVariableValue(const std::string& variableName, double values[3])
  {
    this->SetVectorVariableValue(variableName, values[0], values[1], values[2]);
  }
  void SetVectorVariableValue(int i, double xValue, double yValue, double zValue);
  void SetVectorVariableValue(int i, double values[3])
  {
    this->SetVectorVariableValue(i, values[0], values[1], values[2]);
  }
 
 
  double* GetVectorVariableValue(const std::string& variableName) VTK_SIZEHINT(3);
  void GetVectorVariableValue(const std::string& variableName, double value[3])
  {
    double* r = this->GetVectorVariableValue(variableName);
    value[0] = r[0];
    value[1] = r[1];
    value[2] = r[2];
  }
  double* GetVectorVariableValue(int i) VTK_SIZEHINT(3);
  void GetVectorVariableValue(int i, double value[3])
  {
    double* r = this->GetVectorVariableValue(i);
    value[0] = r[0];
    value[1] = r[1];
    value[2] = r[2];
  }
 
  int GetNumberOfScalarVariables()
  {
    return static_cast<int>(this->UsedScalarVariableNames.size());
  }
 
  int GetScalarVariableIndex(const std::string& name);
 
  int GetNumberOfVectorVariables()
  {
    return static_cast<int>(this->UsedVectorVariableNames.size());
  }
 
  int GetVectorVariableIndex(const std::string& name);
 
  std::string GetScalarVariableName(int i);
 
  std::string GetVectorVariableName(int i);
 
 
  bool GetScalarVariableNeeded(int i);
  bool GetScalarVariableNeeded(const std::string& variableName);
 
 
  bool GetVectorVariableNeeded(int i);
  bool GetVectorVariableNeeded(const std::string& variableName);
 
  void RemoveAllVariables();
 
  void RemoveScalarVariables();
 
  void RemoveVectorVariables();
 
 
  vtkSetMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkGetMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkBooleanMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkSetMacro(ReplacementValue, double);
  vtkGetMacro(ReplacementValue, double);
 
  void InvalidateFunction();
 
  static std::string SanitizeName(const char* name);
 
protected:
  vtkExprTkFunctionParser();
  ~vtkExprTkFunctionParser() override;
 
  enum ParseMode
  {
    DetectReturnType,
    SaveResultInVariable
  };
 
  int Parse(ParseMode mode);
 
  enum VectorReturningFunction
  {
    Cross,
    Norm
  };
 
  std::string FixVectorReturningFunctionOccurrences(
    VectorReturningFunction vectorReturningFunction);
 
  bool CheckOldFormatOfDotProductUsage();
 
  bool Evaluate();
 
  void UpdateNeededVariables();
 
  std::string Function;
  std::string FunctionWithUsedVariableNames;
  std::string ExpressionString;
 
  // original and used variables names are the same, except if the original
  // ones are not valid.
  std::vector<std::string> OriginalScalarVariableNames;
  std::vector<std::string> UsedScalarVariableNames;
  std::vector<std::string> OriginalVectorVariableNames;
  std::vector<std::string> UsedVectorVariableNames;
  // pointers for scalar and vector variables are used to enforce
  // that their memory address will not change due to a possible
  // resizing of their container (std::vector), ExprTk requires the
  // memory address of the given variable to remain the same.
  std::vector<double*> ScalarVariableValues;
  std::vector<vtkTuple<double, 3>*> VectorVariableValues;
  std::vector<bool> ScalarVariableNeeded;
  std::vector<bool> VectorVariableNeeded;
 
  vtkTimeStamp FunctionMTime;
  vtkTimeStamp ParseMTime;
  vtkTimeStamp VariableMTime;
  vtkTimeStamp EvaluateMTime;
 
  vtkTypeBool ReplaceInvalidValues;
  double ReplacementValue;
 
  vtkExprTkTools* ExprTkTools;
 
  int ResultType;
  vtkTuple<double, 3> Result;
 
private:
  vtkExprTkFunctionParser(const vtkExprTkFunctionParser&) = delete;
  void operator=(const vtkExprTkFunctionParser&) = delete;
};
 
#endif