v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  Program:   Visualization Toolkit

  Module:    vtkArrayCalculator.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 vtkArrayCalculator_h

#define vtkArrayCalculator_h


#include "vtkFiltersCoreModule.h" // For export macro

#include "vtkDataSetAlgorithm.h"


class vtkFunctionParser;


#define VTK_ATTRIBUTE_MODE_DEFAULT 0

#define VTK_ATTRIBUTE_MODE_USE_POINT_DATA 1

#define VTK_ATTRIBUTE_MODE_USE_CELL_DATA 2

#define VTK_ATTRIBUTE_MODE_USE_VERTEX_DATA 3

#define VTK_ATTRIBUTE_MODE_USE_EDGE_DATA 4


class VTKFILTERSCORE_EXPORT vtkArrayCalculator : public vtkDataSetAlgorithm

{

public:

  vtkTypeMacro(vtkArrayCalculator,vtkDataSetAlgorithm);

  void PrintSelf(ostream& os, vtkIndent indent);


  static vtkArrayCalculator *New();


  virtual void SetFunction(const char* function);

  vtkGetStringMacro(Function);


  void AddScalarArrayName(const char* arrayName, int component = 0);

  void AddVectorArrayName(const char* arrayName, int component0 = 0,

                          int component1 = 1, int component2 = 2);


  void AddScalarVariable(const char* variableName, const char* arrayName,

                         int component = 0);

  void AddVectorVariable(const char* variableName, const char* arrayName,

                         int component0 = 0, int component1 = 1,

                         int component2 = 2);


  void AddCoordinateScalarVariable(const char* variableName,

                                   int component = 0);

  void AddCoordinateVectorVariable(const char* variableName,

                                   int component0 = 0, int component1 = 1,

                                   int component2 = 2);


  void SetResultArrayName(const char* name);

  vtkGetStringMacro(ResultArrayName);


  vtkGetMacro(ResultArrayType,int);

  vtkSetMacro(ResultArrayType,int);


  vtkGetMacro(CoordinateResults, int);

  vtkSetMacro(CoordinateResults, int);

  vtkBooleanMacro(CoordinateResults, int);


  vtkGetMacro(ResultNormals, bool);

  vtkSetMacro(ResultNormals, bool);

  vtkBooleanMacro(ResultNormals, bool);


  vtkGetMacro(ResultTCoords, bool);

  vtkSetMacro(ResultTCoords, bool);

  vtkBooleanMacro(ResultTCoords, bool);


  vtkSetMacro(AttributeMode,int);

  vtkGetMacro(AttributeMode,int);

  void SetAttributeModeToDefault()

    {this->SetAttributeMode(VTK_ATTRIBUTE_MODE_DEFAULT);};

  void SetAttributeModeToUsePointData()

    {this->SetAttributeMode(VTK_ATTRIBUTE_MODE_USE_POINT_DATA);};

  void SetAttributeModeToUseCellData()

    {this->SetAttributeMode(VTK_ATTRIBUTE_MODE_USE_CELL_DATA);};

  void SetAttributeModeToUseVertexData()

    {this->SetAttributeMode(VTK_ATTRIBUTE_MODE_USE_VERTEX_DATA);};

  void SetAttributeModeToUseEdgeData()

    {this->SetAttributeMode(VTK_ATTRIBUTE_MODE_USE_EDGE_DATA);};

  const char *GetAttributeModeAsString();


  void RemoveAllVariables();


  virtual void RemoveScalarVariables();


  virtual void RemoveVectorVariables();


  virtual void RemoveCoordinateScalarVariables();


  virtual void RemoveCoordinateVectorVariables();


  char** GetScalarArrayNames() { return this->ScalarArrayNames; }

  char* GetScalarArrayName(int i);

  char** GetVectorArrayNames() { return this->VectorArrayNames; }

  char* GetVectorArrayName(int i);

  char** GetScalarVariableNames() { return this->ScalarVariableNames; }

  char* GetScalarVariableName(int i);

  char** GetVectorVariableNames() { return this->VectorVariableNames; }

  char* GetVectorVariableName(int i);

  int* GetSelectedScalarComponents() { return this->SelectedScalarComponents; }

  int GetSelectedScalarComponent(int i);

  int** GetSelectedVectorComponents() { return this->SelectedVectorComponents;}

  int* GetSelectedVectorComponents(int i);

  vtkGetMacro(NumberOfScalarArrays, int);

  vtkGetMacro(NumberOfVectorArrays, int);


  vtkSetMacro(ReplaceInvalidValues,int);

  vtkGetMacro(ReplaceInvalidValues,int);

  vtkBooleanMacro(ReplaceInvalidValues,int);

  vtkSetMacro(ReplacementValue,double);

  vtkGetMacro(ReplacementValue,double);


protected:

  vtkArrayCalculator();

  ~vtkArrayCalculator();


  virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);


  char  * Function;

  char  * ResultArrayName;

  char ** ScalarArrayNames;

  char ** VectorArrayNames;

  char ** ScalarVariableNames;

  char ** VectorVariableNames;

  int     NumberOfScalarArrays;

  int     NumberOfVectorArrays;

  int     AttributeMode;

  int   * SelectedScalarComponents;

  int  ** SelectedVectorComponents;

  vtkFunctionParser* FunctionParser;


  int     ReplaceInvalidValues;

  double  ReplacementValue;


  int     CoordinateResults;

  bool    ResultNormals;

  bool    ResultTCoords;

  char ** CoordinateScalarVariableNames;

  char ** CoordinateVectorVariableNames;

  int   * SelectedCoordinateScalarComponents;

  int  ** SelectedCoordinateVectorComponents;

  int     NumberOfCoordinateScalarArrays;

  int     NumberOfCoordinateVectorArrays;


  int     ResultArrayType;

private:

  vtkArrayCalculator(const vtkArrayCalculator&);  // Not implemented.

  void operator=(const vtkArrayCalculator&);  // Not implemented.

};


#endif