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

  bool CheckAbortAndInvoke();

  void InvokeCleanupAbortCheck();


  void SetContainerAlgorithm(vtkAlgorithm* containerAlg)
  {
    this->ContainerAlgorithm = containerAlg;
  }
  vtkAlgorithm* GetContainerAlgorithm() { return this->ContainerAlgorithm; }


  vtkSetMacro(AbortOutput, bool);
  vtkGetMacro(AbortOutput, bool);
  vtkBooleanMacro(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 bool Update(int port);
  VTK_UNBLOCKTHREADS
  virtual bool 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 bool UpdateInformation();

  virtual bool UpdateDataObject();

  virtual void PropagateUpdateExtent();

  VTK_UNBLOCKTHREADS
  virtual bool 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 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