vtkAlgorithm.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 vtkAlgorithm_h
#define vtkAlgorithm_h
 
#include "vtkArrayComponents.h"            // For enum
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkAlgorithmInternals;
class vtkAlgorithmOutput;
class vtkCollection;
class vtkDataArray;
class vtkDataObject;
class vtkExecutive;
class vtkInformation;
class vtkInformationInformationVectorKey;
class vtkInformationIntegerKey;
class vtkInformationStringKey;
class vtkInformationStringVectorKey;
class vtkInformationVector;
class vtkProgressObserver;
 
class VTKCOMMONEXECUTIONMODEL_EXPORT VTK_MARSHALMANUAL vtkAlgorithm : public vtkObject
{
public:
  static vtkAlgorithm* New();
  vtkTypeMacro(vtkAlgorithm, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum DesiredOutputPrecision
  {
    SINGLE_PRECISION,
    DOUBLE_PRECISION,
    DEFAULT_PRECISION
  };
 
  vtkTypeBool HasExecutive();
 
  vtkExecutive* GetExecutive();
 
  virtual void SetExecutive(vtkExecutive* executive);
 
  virtual vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo);
 
  vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkCollection* inInfo, vtkInformationVector* outInfo);
 
  virtual int ComputePipelineMTime(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec, int requestFromOutputPort, vtkMTimeType* mtime);
 
  virtual int ModifyRequest(vtkInformation* request, int when);
 
  vtkInformation* GetInputPortInformation(int port);
 
  vtkInformation* GetOutputPortInformation(int port);
 
 
  vtkGetObjectMacro(Information, vtkInformation);
  virtual void SetInformation(vtkInformation*);
 
  int GetNumberOfInputPorts();
 
  int GetNumberOfOutputPorts();
 
 
  bool UsesGarbageCollector() const override { return true; }
 
  void SetAbortExecuteAndUpdateTime();
 
 
  vtkSetMacro(AbortExecute, vtkTypeBool);
  vtkGetMacro(AbortExecute, vtkTypeBool);
  vtkBooleanMacro(AbortExecute, vtkTypeBool);
 
 
  vtkGetMacro(Progress, double);
 
  void UpdateProgress(double amount);
 
  bool CheckAbort();
 
 
  void SetContainerAlgorithm(vtkAlgorithm* containerAlg)
  {
    this->ContainerAlgorithm = containerAlg;
  }
  vtkAlgorithm* GetContainerAlgorithm() { return this->ContainerAlgorithm; }
 
 
  vtkSetMacro(AbortOutput, bool);
  vtkGetMacro(AbortOutput, bool);
 
 
  void SetProgressShiftScale(double shift, double scale);
  vtkGetMacro(ProgressShift, double);
  vtkGetMacro(ProgressScale, double);
 
 
  void SetProgressText(const char* ptext);
  vtkGetStringMacro(ProgressText);
 
 
  vtkGetMacro(ErrorCode, unsigned long);
 
  // left public for performance since it is used in inner loops
  std::atomic<vtkTypeBool> AbortExecute;
 
  static vtkInformationIntegerKey* INPUT_IS_OPTIONAL();
  static vtkInformationIntegerKey* INPUT_IS_REPEATABLE();
  static vtkInformationInformationVectorKey* INPUT_REQUIRED_FIELDS();
  static vtkInformationStringVectorKey* INPUT_REQUIRED_DATA_TYPE();
  static vtkInformationInformationVectorKey* INPUT_ARRAYS_TO_PROCESS();
  static vtkInformationIntegerKey* INPUT_PORT();
  static vtkInformationIntegerKey* INPUT_CONNECTION();
 
  static vtkInformationIntegerKey* CAN_PRODUCE_SUB_EXTENT();
 
  static vtkInformationIntegerKey* CAN_HANDLE_PIECE_REQUEST();
 
  static vtkInformationIntegerKey* ABORTED();
 
 
  void SetInputArrayToProcess(
    const char* name, int fieldAssociation, int component = vtkArrayComponents::AllComponents);
 
  virtual void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, const char* name);
  virtual void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, const char* name, int component);
 
 
  virtual void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, int fieldAttributeType);
  virtual void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, int fieldAttributeType, int component);
 
  virtual void SetInputArrayToProcess(int idx, vtkInformation* info);
 
 
  virtual void SetInputArrayToProcess(int idx, int port, int connection,
    const char* fieldAssociation, const char* attributeTypeorName);
  virtual void SetInputArrayToProcess(int idx, int port, int connection,
    const char* fieldAssociation, const char* attributeTypeorName, const char* component);
 
  int GetNumberOfInputArraySpecifications();
 
  bool ResetInputArraySpecifications();
 
  vtkInformation* GetInputArrayInformation(int idx);
 
  // from here down are convenience methods that really are executive methods
 
  void RemoveAllInputs();
 
  vtkDataObject* GetOutputDataObject(int port);
 
  vtkDataObject* GetInputDataObject(int port, int connection);
 
 
  virtual void SetInputConnection(int port, vtkAlgorithmOutput* input);
  virtual void SetInputConnection(vtkAlgorithmOutput* input);
 
 
  virtual void AddInputConnection(int port, vtkAlgorithmOutput* input);
  virtual void AddInputConnection(vtkAlgorithmOutput* input);
 
  virtual void RemoveInputConnection(int port, vtkAlgorithmOutput* input);
 
  virtual void RemoveInputConnection(int port, int idx);
 
  virtual void RemoveAllInputConnections(int port);
 
  virtual void SetInputDataObject(int port, vtkDataObject* data);
  virtual void SetInputDataObject(vtkDataObject* data) { this->SetInputDataObject(0, data); }
 
  virtual void AddInputDataObject(int port, vtkDataObject* data);
  virtual void AddInputDataObject(vtkDataObject* data) { this->AddInputDataObject(0, data); }
 
  vtkAlgorithmOutput* GetOutputPort(int index);
  vtkAlgorithmOutput* GetOutputPort() { return this->GetOutputPort(0); }
 
  int GetNumberOfInputConnections(int port);
 
  int GetTotalNumberOfInputConnections();
 
  vtkAlgorithmOutput* GetInputConnection(int port, int index);
 
  vtkAlgorithm* GetInputAlgorithm(int port, int index, int& algPort);
 
  vtkAlgorithm* GetInputAlgorithm(int port, int index);
 
  vtkAlgorithm* GetInputAlgorithm() { return this->GetInputAlgorithm(0, 0); }
 
  vtkExecutive* GetInputExecutive(int port, int index);
 
  vtkExecutive* GetInputExecutive() { return this->GetInputExecutive(0, 0); }
 
  vtkInformation* GetInputInformation(int port, int index);
 
  vtkInformation* GetInputInformation() { return this->GetInputInformation(0, 0); }
 
  vtkInformation* GetOutputInformation(int port);
 
 
  VTK_UNBLOCKTHREADS
  virtual void Update(int port);
  VTK_UNBLOCKTHREADS
  virtual void Update();
 
  virtual vtkTypeBool Update(int port, vtkInformationVector* requests);
 
  virtual vtkTypeBool Update(vtkInformation* requests);
 
  virtual int UpdatePiece(
    int piece, int numPieces, int ghostLevels, const int extents[6] = nullptr);
 
  VTK_UNBLOCKTHREADS
  virtual int UpdateExtent(const int extents[6]);
 
  VTK_UNBLOCKTHREADS
  virtual int UpdateTimeStep(double time, int piece = -1, int numPieces = 1, int ghostLevels = 0,
    const int extents[6] = nullptr);
 
  VTK_UNBLOCKTHREADS
  virtual void UpdateInformation();
 
  virtual void UpdateDataObject();
 
  virtual void PropagateUpdateExtent();
 
  VTK_UNBLOCKTHREADS
  virtual void UpdateWholeExtent();
 
  void ConvertTotalInputToPortConnection(int ind, int& port, int& conn);
 
  //======================================================================
  // The following block of code is to support old style VTK applications. If
  // you are using these calls there are better ways to do it in the new
  // pipeline
  //======================================================================
 
 
  virtual void SetReleaseDataFlag(vtkTypeBool);
  virtual vtkTypeBool GetReleaseDataFlag();
  void ReleaseDataFlagOn();
  void ReleaseDataFlagOff();
 
  //========================================================================
 
 
  int UpdateExtentIsEmpty(vtkInformation* pinfo, vtkDataObject* output);
  int UpdateExtentIsEmpty(vtkInformation* pinfo, int extentType);
 
  static void SetDefaultExecutivePrototype(vtkExecutive* proto);
 
 
  int* GetUpdateExtent() VTK_SIZEHINT(6) { return this->GetUpdateExtent(0); }
  int* GetUpdateExtent(int port) VTK_SIZEHINT(6);
  void GetUpdateExtent(int& x0, int& x1, int& y0, int& y1, int& z0, int& z1)
  {
    this->GetUpdateExtent(0, x0, x1, y0, y1, z0, z1);
  }
  void GetUpdateExtent(int port, int& x0, int& x1, int& y0, int& y1, int& z0, int& z1);
  void GetUpdateExtent(int extent[6]) { this->GetUpdateExtent(0, extent); }
  void GetUpdateExtent(int port, int extent[6]);
 
 
  int GetUpdatePiece() { return this->GetUpdatePiece(0); }
  int GetUpdatePiece(int port);
  int GetUpdateNumberOfPieces() { return this->GetUpdateNumberOfPieces(0); }
  int GetUpdateNumberOfPieces(int port);
  int GetUpdateGhostLevel() { return this->GetUpdateGhostLevel(0); }
  int GetUpdateGhostLevel(int port);
 
 
  void SetProgressObserver(vtkProgressObserver*);
  vtkGetObjectMacro(ProgressObserver, vtkProgressObserver);
 
 
  void SetNoPriorTemporalAccessInformationKey(int key);
  void SetNoPriorTemporalAccessInformationKey();
 
  void RemoveNoPriorTemporalAccessInformationKey();
 
protected:
  vtkAlgorithm();
  ~vtkAlgorithm() override;
 
  // Time stamp to store the last time any filter was aborted.
  static vtkTimeStamp LastAbortTime;
 
  // Time stamp to store the last time this filter checked for an
  // abort.
  vtkTimeStamp LastAbortCheckTime;
 
  // Keys used to indicate that input/output port information has been
  // filled.
  static vtkInformationIntegerKey* PORT_REQUIREMENTS_FILLED();
 
  // Arbitrary extra information associated with this algorithm
  vtkInformation* Information;
 
  bool CheckUpstreamAbort();
 
  virtual int FillInputPortInformation(int port, vtkInformation* info);
 
  virtual int FillOutputPortInformation(int port, vtkInformation* info);
 
  virtual void SetNumberOfInputPorts(int n);
 
  virtual void SetNumberOfOutputPorts(int n);
 
  // Helper methods to check input/output port index ranges.
  int InputPortIndexInRange(int index, const char* action);
  int OutputPortIndexInRange(int index, const char* action);
 
  int GetInputArrayAssociation(int idx, vtkInformationVector** inputVector);
 
 
  int GetInputArrayAssociation(int idx, int connection, vtkInformationVector** inputVector);
  int GetInputArrayAssociation(int idx, vtkDataObject* input);
 
  int GetInputArrayComponent(int idx);
 
 
  vtkDataArray* GetInputArrayToProcess(int idx, vtkInformationVector** inputVector);
  vtkDataArray* GetInputArrayToProcess(
    int idx, vtkInformationVector** inputVector, int& association);
 
 
  vtkDataArray* GetInputArrayToProcess(int idx, int connection, vtkInformationVector** inputVector);
  vtkDataArray* GetInputArrayToProcess(
    int idx, int connection, vtkInformationVector** inputVector, int& association);
  vtkDataArray* GetInputArrayToProcess(int idx, vtkDataObject* input);
  vtkDataArray* GetInputArrayToProcess(int idx, vtkDataObject* input, int& association);
 
 
  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkInformationVector** inputVector);
  vtkAbstractArray* GetInputAbstractArrayToProcess(
    int idx, vtkInformationVector** inputVector, int& association);
 
 
  vtkAbstractArray* GetInputAbstractArrayToProcess(
    int idx, int connection, vtkInformationVector** inputVector);
  vtkAbstractArray* GetInputAbstractArrayToProcess(
    int idx, int connection, vtkInformationVector** inputVector, int& association);
  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkDataObject* input);
  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkDataObject* input, int& association);
 
 
  vtkSmartPointer<vtkAbstractArray> GetInputArray(int idx, int connection,
    vtkInformationVector** inputVector, int& association,
    int requestedComponent = vtkArrayComponents::Requested);
  vtkSmartPointer<vtkAbstractArray> GetInputArray(int idx, vtkDataObject* input, int& association,
    int requestedComponent = vtkArrayComponents::Requested);
  template <typename ArrayType, typename... Params>
  vtkSmartPointer<ArrayType> GetInputArrayAs(Params&&... params)
  {
    auto abstractArray = this->GetInputArray(std::forward<Params>(params)...);
    auto* castArray = ArrayType::SafeDownCast(abstractArray.GetPointer());
    auto result = vtkSmartPointer<ArrayType>(castArray);
    return result;
  }
 
  vtkInformation* GetInputArrayFieldInformation(int idx, vtkInformationVector** inputVector);
 
  virtual vtkExecutive* CreateDefaultExecutive();
 
 
  vtkSetMacro(ErrorCode, unsigned long);
  unsigned long ErrorCode;
 
  // Progress/Update handling
  double Progress;
  char* ProgressText;
 
  // Garbage collection support.
  void ReportReferences(vtkGarbageCollector*) override;
 
  // executive methods below
 
  virtual void SetNthInputConnection(int port, int index, vtkAlgorithmOutput* input);
 
  virtual void SetNumberOfInputConnections(int port, int n);
 
  static vtkExecutive* DefaultExecutivePrototype;
 
  void SetInputDataInternal(int port, vtkDataObject* input)
  {
    this->SetInputDataObject(port, input);
  }
  void AddInputDataInternal(int port, vtkDataObject* input)
  {
    this->AddInputDataObject(port, input);
  }
 
  vtkProgressObserver* ProgressObserver;
 
private:
  vtkExecutive* Executive;
  vtkInformationVector* InputPortInformation;
  vtkInformationVector* OutputPortInformation;
  vtkAlgorithmInternals* AlgorithmInternal;
  static void ConnectionAdd(
    vtkAlgorithm* producer, int producerPort, vtkAlgorithm* consumer, int consumerPort);
  static void ConnectionRemove(
    vtkAlgorithm* producer, int producerPort, vtkAlgorithm* consumer, int consumerPort);
  static void ConnectionRemoveAllInput(vtkAlgorithm* consumer, int port);
  static void ConnectionRemoveAllOutput(vtkAlgorithm* producer, int port);
 
  vtkAlgorithm(const vtkAlgorithm&) = delete;
  void operator=(const vtkAlgorithm&) = delete;
 
  double ProgressShift;
  double ProgressScale;
  vtkAlgorithm* ContainerAlgorithm;
  bool AbortOutput;
};
 
VTK_ABI_NAMESPACE_END
#endif