vtkAbstractInterpolatedVelocityField.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 vtkAbstractInterpolatedVelocityField_h
#define vtkAbstractInterpolatedVelocityField_h

#include "vtkDeprecation.h"            // For VTK_DEPRECATED_IN_9_7_0
#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkFunctionSet.h"
#include "vtkNew.h"          // for vtkNew
#include "vtkSmartPointer.h" // for vtkSmartPointer

#include <vector> // for weights

VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractCellLocator;
class vtkCompositeDataSet;
class vtkDataObject;
class vtkDataSet;
class vtkDataArray;
class vtkIdList;
class vtkPointData;
class vtkGenericCell;
class vtkFindCellStrategy;

class VTKFILTERSFLOWPATHS_EXPORT vtkAbstractInterpolatedVelocityField : public vtkFunctionSet
{
public:

  vtkTypeMacro(vtkAbstractInterpolatedVelocityField, vtkFunctionSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  // Keep track of how the interpolated velocity field is
  // initialized. Currently, all datasets that compose the velocity field are
  // initialized (meaning that supporting structures like locators are
  // built).
  enum VelocityFieldInitializationState
  {
    NOT_INITIALIZED = 0,
    INITIALIZE_ALL_DATASETS = 1,
    SELF_INITIALIZE = 2
  };


  virtual void Initialize(
    vtkCompositeDataSet* compDS, int initCellLocator = INITIALIZE_ALL_DATASETS);
  vtkGetMacro(InitializationState, int);


  vtkSetMacro(Caching, bool);
  vtkGetMacro(Caching, bool);


  vtkGetMacro(CacheHit, int);
  vtkGetMacro(CacheMiss, int);

  vtkGetObjectMacro(LastDataSet, vtkDataSet);


  vtkGetMacro(LastCellId, vtkIdType);
  virtual void SetLastCellId(vtkIdType c) { this->LastCellId = c; }

  virtual void SetLastCellId(vtkIdType c, int dataindex) = 0;


  vtkGetStringMacro(VectorsSelection);
  vtkGetMacro(VectorsType, int);

  void SelectVectors(int fieldAssociation, const char* fieldName);


  vtkSetMacro(NormalizeVector, bool);
  vtkGetMacro(NormalizeVector, bool);


  vtkSetMacro(ForceSurfaceTangentVector, bool);
  vtkGetMacro(ForceSurfaceTangentVector, bool);


  vtkSetMacro(SurfaceDataset, bool);
  vtkGetMacro(SurfaceDataset, bool);

  virtual void CopyParameters(vtkAbstractInterpolatedVelocityField* from);

  using Superclass::FunctionValues;
  int FunctionValues(double* x, double* f) override = 0;

  void ClearLastCellId() { this->LastCellId = -1; }


  int GetLastWeights(double* w);
  int GetLastLocalCoordinates(double pcoords[3]);


  VTK_DEPRECATED_IN_9_7_0("Use SetCellLocator() instead.")
  virtual void SetFindCellStrategy(vtkFindCellStrategy*);
  VTK_DEPRECATED_IN_9_7_0(
    "GetFindCellStrategy() always returns nullptr. Use GetCellLocator() instead.")
  virtual vtkFindCellStrategy* GetFindCellStrategy() { return nullptr; }


  virtual void SetCellLocator(vtkAbstractCellLocator*);
  vtkGetObjectMacro(CellLocator, vtkAbstractCellLocator);

protected:
  vtkAbstractInterpolatedVelocityField();
  ~vtkAbstractInterpolatedVelocityField() override;

  static const double TOLERANCE_SCALE;
  static const double SURFACE_TOLERANCE_SCALE;

  int CacheHit;
  int CacheMiss;
  bool Caching;
  bool NormalizeVector;
  bool ForceSurfaceTangentVector;
  bool SurfaceDataset;
  int VectorsType;
  char* VectorsSelection;
  std::vector<double> Weights;
  double LastPCoords[3];
  int LastSubId;
  double LastClosestPoint[3];
  vtkIdType LastCellId;
  vtkDataSet* LastDataSet;
  vtkNew<vtkGenericCell> CurrentCell;
  vtkNew<vtkIdList> PointIds;

  int InitializationState;

  // This is used to keep track of the cellLocator and vector array
  // associated with each dataset forming the velocity field. Note that the
  // cellLocator can be null, this means the FindCell is invoked
  // using the dataset's FindCell() method.
  struct vtkDataSetInformation
  {
    vtkDataSet* DataSet;
    const double SampledMaxCellLength2;
    const double Length2;
    vtkAbstractCellLocator* CellLocator;
    vtkDataArray* Vectors;

    vtkDataSetInformation(
      vtkDataSet* dataSet, vtkAbstractCellLocator* cellLocator, vtkDataArray* vectors);
  };

  vtkAbstractCellLocator* CellLocator;
  std::vector<vtkDataSetInformation> DataSetsInfo;
  std::vector<vtkDataSetInformation>::iterator GetDataSetInfo(vtkDataSet* dataset);


  vtkSetStringMacro(VectorsSelection);

  virtual int FunctionValues(vtkDataSet* ds, double* x, double* f);

  virtual bool FindAndUpdateCell(const vtkDataSetInformation& dsInfo, double* x);

  friend class vtkTemporalInterpolatedVelocityField;

  void FastCompute(vtkDataArray* vectors, double f[3]);
  void FastCompute(vtkAbstractInterpolatedVelocityField* inIVF, vtkDataArray* vectors, double f[3]);
  bool InterpolatePoint(vtkPointData* outPD, vtkIdType outIndex);
  bool InterpolatePoint(
    vtkAbstractInterpolatedVelocityField* inIVF, vtkPointData* outPD, vtkIdType outIndex);
  vtkGenericCell* GetLastCell()
  {
    return (this->LastCellId != -1) ? this->CurrentCell.Get() : nullptr;
  }


  virtual int SelfInitialize() { return 0; }
  void AddToDataSetsInfo(vtkDataSet*, vtkAbstractCellLocator*, vtkDataArray* vectors);
  size_t GetDataSetsInfoSize();

private:
  vtkAbstractInterpolatedVelocityField(const vtkAbstractInterpolatedVelocityField&) = delete;
  void operator=(const vtkAbstractInterpolatedVelocityField&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif