VTK  9.0.1
vtkAlgorithm.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkAlgorithm.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
41 #ifndef vtkAlgorithm_h
42 #define vtkAlgorithm_h
43 
44 #include "vtkCommonExecutionModelModule.h" // For export macro
45 #include "vtkObject.h"
46 
47 class vtkAbstractArray;
48 class vtkAlgorithmInternals;
49 class vtkAlgorithmOutput;
50 class vtkCollection;
51 class vtkDataArray;
52 class vtkDataObject;
53 class vtkExecutive;
54 class vtkInformation;
61 
62 class VTKCOMMONEXECUTIONMODEL_EXPORT vtkAlgorithm : public vtkObject
63 {
64 public:
65  static vtkAlgorithm* New();
66  vtkTypeMacro(vtkAlgorithm, vtkObject);
67  void PrintSelf(ostream& os, vtkIndent indent) override;
68 
90  {
93  DEFAULT_PRECISION
94  };
95 
100  int HasExecutive();
101 
106  vtkExecutive* GetExecutive();
107 
113  virtual void SetExecutive(vtkExecutive* executive);
114 
138  virtual vtkTypeBool ProcessRequest(
139  vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo);
140 
145  vtkTypeBool ProcessRequest(
146  vtkInformation* request, vtkCollection* inInfo, vtkInformationVector* outInfo);
147 
153  virtual int ComputePipelineMTime(vtkInformation* request, vtkInformationVector** inInfoVec,
154  vtkInformationVector* outInfoVec, int requestFromOutputPort, vtkMTimeType* mtime);
155 
163  virtual int ModifyRequest(vtkInformation* request, int when);
164 
171  vtkInformation* GetInputPortInformation(int port);
172 
179  vtkInformation* GetOutputPortInformation(int port);
180 
182 
185  vtkGetObjectMacro(Information, vtkInformation);
186  virtual void SetInformation(vtkInformation*);
188 
192  int GetNumberOfInputPorts();
193 
197  int GetNumberOfOutputPorts();
198 
200 
203  void Register(vtkObjectBase* o) override;
204  void UnRegister(vtkObjectBase* o) override;
206 
208 
212  vtkSetMacro(AbortExecute, vtkTypeBool);
213  vtkGetMacro(AbortExecute, vtkTypeBool);
214  vtkBooleanMacro(AbortExecute, vtkTypeBool);
216 
218 
221  vtkGetMacro(Progress, double);
223 
228  VTK_LEGACY(void SetProgress(double));
229 
235  void UpdateProgress(double amount);
236 
238 
250  void SetProgressShiftScale(double shift, double scale);
251  vtkGetMacro(ProgressShift, double);
252  vtkGetMacro(ProgressScale, double);
254 
256 
263  void SetProgressText(const char* ptext);
264  vtkGetStringMacro(ProgressText);
266 
268 
272  vtkGetMacro(ErrorCode, unsigned long);
274 
275  // left public for performance since it is used in inner loops
277 
282  static vtkInformationIntegerKey* INPUT_IS_OPTIONAL();
286  static vtkInformationIntegerKey* INPUT_IS_REPEATABLE();
290  static vtkInformationInformationVectorKey* INPUT_REQUIRED_FIELDS();
294  static vtkInformationStringVectorKey* INPUT_REQUIRED_DATA_TYPE();
298  static vtkInformationInformationVectorKey* INPUT_ARRAYS_TO_PROCESS();
302  static vtkInformationIntegerKey* INPUT_PORT();
306  static vtkInformationIntegerKey* INPUT_CONNECTION();
307 
316  static vtkInformationIntegerKey* CAN_PRODUCE_SUB_EXTENT();
317 
330  static vtkInformationIntegerKey* CAN_HANDLE_PIECE_REQUEST();
331 
333 
341  virtual void SetInputArrayToProcess(
342  int idx, int port, int connection, int fieldAssociation, const char* name);
343  virtual void SetInputArrayToProcess(
344  int idx, int port, int connection, int fieldAssociation, int fieldAttributeType);
345  virtual void SetInputArrayToProcess(int idx, vtkInformation* info);
347 
371  virtual void SetInputArrayToProcess(int idx, int port, int connection,
372  const char* fieldAssociation, const char* attributeTypeorName);
373 
377  vtkInformation* GetInputArrayInformation(int idx);
378 
379  // from here down are convenience methods that really are executive methods
380 
384  void RemoveAllInputs();
385 
390  vtkDataObject* GetOutputDataObject(int port);
391 
396  vtkDataObject* GetInputDataObject(int port, int connection);
397 
399 
412  virtual void SetInputConnection(int port, vtkAlgorithmOutput* input);
413  virtual void SetInputConnection(vtkAlgorithmOutput* input);
415 
417 
426  virtual void AddInputConnection(int port, vtkAlgorithmOutput* input);
427  virtual void AddInputConnection(vtkAlgorithmOutput* input);
429 
439  virtual void RemoveInputConnection(int port, vtkAlgorithmOutput* input);
440 
444  virtual void RemoveInputConnection(int port, int idx);
445 
449  virtual void RemoveAllInputConnections(int port);
450 
459  virtual void SetInputDataObject(int port, vtkDataObject* data);
460  virtual void SetInputDataObject(vtkDataObject* data) { this->SetInputDataObject(0, data); }
461 
467  virtual void AddInputDataObject(int port, vtkDataObject* data);
468  virtual void AddInputDataObject(vtkDataObject* data) { this->AddInputDataObject(0, data); }
469 
476  vtkAlgorithmOutput* GetOutputPort(int index);
478 
482  int GetNumberOfInputConnections(int port);
483 
487  int GetTotalNumberOfInputConnections();
488 
492  vtkAlgorithmOutput* GetInputConnection(int port, int index);
493 
498  vtkAlgorithm* GetInputAlgorithm(int port, int index, int& algPort);
499 
503  vtkAlgorithm* GetInputAlgorithm(int port, int index);
504 
509 
514  vtkExecutive* GetInputExecutive(int port, int index);
515 
520 
529  vtkInformation* GetInputInformation(int port, int index);
530 
535 
543  vtkInformation* GetOutputInformation(int port);
544 
546 
549  virtual void Update(int port);
550  virtual void Update();
552 
575  virtual vtkTypeBool Update(int port, vtkInformationVector* requests);
576 
582  virtual vtkTypeBool Update(vtkInformation* requests);
583 
590  virtual int UpdatePiece(
591  int piece, int numPieces, int ghostLevels, const int extents[6] = nullptr);
592 
598  virtual int UpdateExtent(const int extents[6]);
599 
606  virtual int UpdateTimeStep(double time, int piece = -1, int numPieces = 1, int ghostLevels = 0,
607  const int extents[6] = nullptr);
608 
612  virtual void UpdateInformation();
613 
617  virtual void UpdateDataObject();
618 
622  virtual void PropagateUpdateExtent();
623 
627  virtual void UpdateWholeExtent();
628 
633  void ConvertTotalInputToPortConnection(int ind, int& port, int& conn);
634 
635  //======================================================================
636  // The following block of code is to support old style VTK applications. If
637  // you are using these calls there are better ways to do it in the new
638  // pipeline
639  //======================================================================
640 
642 
645  virtual void SetReleaseDataFlag(int);
646  virtual int GetReleaseDataFlag();
647  void ReleaseDataFlagOn();
648  void ReleaseDataFlagOff();
650 
651  //========================================================================
652 
654 
660  int UpdateExtentIsEmpty(vtkInformation* pinfo, vtkDataObject* output);
661  int UpdateExtentIsEmpty(vtkInformation* pinfo, int extentType);
663 
668  static void SetDefaultExecutivePrototype(vtkExecutive* proto);
669 
671 
676  int* GetUpdateExtent() VTK_SIZEHINT(6) { return this->GetUpdateExtent(0); }
677  int* GetUpdateExtent(int port) VTK_SIZEHINT(6);
678  void GetUpdateExtent(int& x0, int& x1, int& y0, int& y1, int& z0, int& z1)
679  {
680  this->GetUpdateExtent(0, x0, x1, y0, y1, z0, z1);
681  }
682  void GetUpdateExtent(int port, int& x0, int& x1, int& y0, int& y1, int& z0, int& z1);
683  void GetUpdateExtent(int extent[6]) { this->GetUpdateExtent(0, extent); }
684  void GetUpdateExtent(int port, int extent[6]);
686 
688 
693  int GetUpdatePiece() { return this->GetUpdatePiece(0); }
694  int GetUpdatePiece(int port);
696  int GetUpdateNumberOfPieces(int port);
697  int GetUpdateGhostLevel() { return this->GetUpdateGhostLevel(0); }
698  int GetUpdateGhostLevel(int port);
700 
702 
711  void SetProgressObserver(vtkProgressObserver*);
712  vtkGetObjectMacro(ProgressObserver, vtkProgressObserver);
714 
715 protected:
716  vtkAlgorithm();
717  ~vtkAlgorithm() override;
718 
719  // Keys used to indicate that input/output port information has been
720  // filled.
721  static vtkInformationIntegerKey* PORT_REQUIREMENTS_FILLED();
722 
723  // Arbitrary extra information associated with this algorithm
725 
731  virtual int FillInputPortInformation(int port, vtkInformation* info);
732 
738  virtual int FillOutputPortInformation(int port, vtkInformation* info);
739 
743  virtual void SetNumberOfInputPorts(int n);
744 
748  virtual void SetNumberOfOutputPorts(int n);
749 
750  // Helper methods to check input/output port index ranges.
751  int InputPortIndexInRange(int index, const char* action);
752  int OutputPortIndexInRange(int index, const char* action);
753 
758  int GetInputArrayAssociation(int idx, vtkInformationVector** inputVector);
759 
761 
769  int GetInputArrayAssociation(int idx, int connection, vtkInformationVector** inputVector);
770  int GetInputArrayAssociation(int idx, vtkDataObject* input);
772 
774 
778  vtkDataArray* GetInputArrayToProcess(int idx, vtkInformationVector** inputVector);
779  vtkDataArray* GetInputArrayToProcess(
780  int idx, vtkInformationVector** inputVector, int& association);
782 
784 
792  vtkDataArray* GetInputArrayToProcess(int idx, int connection, vtkInformationVector** inputVector);
793  vtkDataArray* GetInputArrayToProcess(
794  int idx, int connection, vtkInformationVector** inputVector, int& association);
795  vtkDataArray* GetInputArrayToProcess(int idx, vtkDataObject* input);
796  vtkDataArray* GetInputArrayToProcess(int idx, vtkDataObject* input, int& association);
798 
800 
804  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkInformationVector** inputVector);
805  vtkAbstractArray* GetInputAbstractArrayToProcess(
806  int idx, vtkInformationVector** inputVector, int& association);
808 
810 
818  vtkAbstractArray* GetInputAbstractArrayToProcess(
819  int idx, int connection, vtkInformationVector** inputVector);
820  vtkAbstractArray* GetInputAbstractArrayToProcess(
821  int idx, int connection, vtkInformationVector** inputVector, int& association);
822  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkDataObject* input);
823  vtkAbstractArray* GetInputAbstractArrayToProcess(int idx, vtkDataObject* input, int& association);
825 
833  vtkInformation* GetInputArrayFieldInformation(int idx, vtkInformationVector** inputVector);
834 
841  virtual vtkExecutive* CreateDefaultExecutive();
842 
844 
848  vtkSetMacro(ErrorCode, unsigned long);
849  unsigned long ErrorCode;
851 
852  // Progress/Update handling
853  double Progress;
855 
856  // Garbage collection support.
857  void ReportReferences(vtkGarbageCollector*) override;
858 
859  // executive methods below
860 
867  virtual void SetNthInputConnection(int port, int index, vtkAlgorithmOutput* input);
868 
875  virtual void SetNumberOfInputConnections(int port, int n);
876 
878 
886  {
887  this->SetInputDataObject(port, input);
888  }
890  {
891  this->AddInputDataObject(port, input);
892  }
893 
895 
896 private:
897  vtkExecutive* Executive;
898  vtkInformationVector* InputPortInformation;
899  vtkInformationVector* OutputPortInformation;
900  vtkAlgorithmInternals* AlgorithmInternal;
901  static void ConnectionAdd(
902  vtkAlgorithm* producer, int producerPort, vtkAlgorithm* consumer, int consumerPort);
903  static void ConnectionRemove(
904  vtkAlgorithm* producer, int producerPort, vtkAlgorithm* consumer, int consumerPort);
905  static void ConnectionRemoveAllInput(vtkAlgorithm* consumer, int port);
906  static void ConnectionRemoveAllOutput(vtkAlgorithm* producer, int port);
907 
908 private:
909  vtkAlgorithm(const vtkAlgorithm&) = delete;
910  void operator=(const vtkAlgorithm&) = delete;
911 
912  double ProgressShift;
913  double ProgressScale;
914 };
915 
916 #endif
vtkAlgorithm::AbortExecute
vtkTypeBool AbortExecute
Definition: vtkAlgorithm.h:272
vtkAlgorithm::Information
vtkInformation * Information
Definition: vtkAlgorithm.h:724
vtkInformationStringKey
Key for string values in vtkInformation.
Definition: vtkInformationStringKey.h:33
vtkAlgorithm::GetUpdateExtent
void GetUpdateExtent(int extent[6])
Definition: vtkAlgorithm.h:683
vtkAlgorithm::DOUBLE_PRECISION
@ DOUBLE_PRECISION
Definition: vtkAlgorithm.h:92
vtkX3D::scale
@ scale
Definition: vtkX3D.h:235
vtkAlgorithm::GetOutputPort
vtkAlgorithmOutput * GetOutputPort()
Definition: vtkAlgorithm.h:477
vtkAlgorithm::AddInputDataObject
virtual void AddInputDataObject(vtkDataObject *data)
Definition: vtkAlgorithm.h:468
vtkObjectBase::Register
virtual void Register(vtkObjectBase *o)
Increase the reference count (mark as used by another object).
vtkAlgorithm
Superclass for all sources, filters, and sinks in VTK.
Definition: vtkAlgorithm.h:62
vtkAlgorithm::SetInputDataObject
virtual void SetInputDataObject(vtkDataObject *data)
Definition: vtkAlgorithm.h:460
vtkX3D::data
@ data
Definition: vtkX3D.h:321
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:35
vtkObjectBase::ReportReferences
virtual void ReportReferences(vtkGarbageCollector *)
vtkObject::New
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
vtkAlgorithm::GetUpdateGhostLevel
int GetUpdateGhostLevel()
Definition: vtkAlgorithm.h:697
vtkAlgorithm::ErrorCode
unsigned long ErrorCode
Definition: vtkAlgorithm.h:848
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:62
vtkAlgorithm::GetUpdatePiece
int GetUpdatePiece()
These functions return the update extent for output ports that use piece extents.
Definition: vtkAlgorithm.h:693
vtkAlgorithm::SetInputDataInternal
void SetInputDataInternal(int port, vtkDataObject *input)
These methods are used by subclasses to implement methods to set data objects directly as input.
Definition: vtkAlgorithm.h:885
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkX3D::time
@ time
Definition: vtkX3D.h:503
vtkAlgorithm::GetUpdateExtent
void GetUpdateExtent(int &x0, int &x1, int &y0, int &y1, int &z0, int &z1)
Definition: vtkAlgorithm.h:678
vtkAlgorithm::ProgressObserver
vtkProgressObserver * ProgressObserver
Definition: vtkAlgorithm.h:894
vtkX3D::port
@ port
Definition: vtkX3D.h:453
vtkExecutive
Superclass for all pipeline executives in VTK.
Definition: vtkExecutive.h:46
vtkCollection
create and manipulate ordered lists of objects
Definition: vtkCollection.h:52
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:45
vtkAlgorithm::GetUpdateNumberOfPieces
int GetUpdateNumberOfPieces()
Definition: vtkAlgorithm.h:695
vtkObjectBase
abstract base class for most VTK objects
Definition: vtkObjectBase.h:63
vtkInformationIntegerKey
Key for integer values in vtkInformation.
Definition: vtkInformationIntegerKey.h:31
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkAlgorithm::GetUpdateExtent
int * GetUpdateExtent()
These functions return the update extent for output ports that use 3D extents.
Definition: vtkAlgorithm.h:676
vtkAlgorithm::ProgressText
char * ProgressText
Definition: vtkAlgorithm.h:854
vtkObject::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkAlgorithm::Progress
double Progress
Definition: vtkAlgorithm.h:853
vtkX3D::name
@ name
Definition: vtkX3D.h:225
vtkGarbageCollector
Detect and break reference loops.
Definition: vtkGarbageCollector.h:94
vtkObject.h
vtkAlgorithm::SINGLE_PRECISION
@ SINGLE_PRECISION
Definition: vtkAlgorithm.h:91
vtkAbstractArray
Abstract superclass for all arrays.
Definition: vtkAbstractArray.h:75
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:73
vtkX3D::info
@ info
Definition: vtkX3D.h:382
vtkAlgorithm::GetInputInformation
vtkInformation * GetInputInformation()
Equivalent to GetInputInformation(0, 0)
Definition: vtkAlgorithm.h:534
vtkAlgorithm::GetInputAlgorithm
vtkAlgorithm * GetInputAlgorithm()
Equivalent to GetInputAlgorithm(0, 0).
Definition: vtkAlgorithm.h:508
vtkInformationStringVectorKey
Key for String vector values.
Definition: vtkInformationStringVectorKey.h:33
vtkAlgorithmOutput
Proxy object to connect input/output ports.
Definition: vtkAlgorithmOutput.h:36
vtkAlgorithm::GetInputExecutive
vtkExecutive * GetInputExecutive()
Equivalent to GetInputExecutive(0, 0)
Definition: vtkAlgorithm.h:519
vtkInformationInformationVectorKey
Key for vtkInformation vectors.
Definition: vtkInformationInformationVectorKey.h:33
vtkX3D::extent
@ extent
Definition: vtkX3D.h:351
vtkProgressObserver
Basic class to optionally replace vtkAlgorithm progress functionality.
Definition: vtkProgressObserver.h:39
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:59
vtkAlgorithm::DefaultExecutivePrototype
static vtkExecutive * DefaultExecutivePrototype
Definition: vtkAlgorithm.h:877
vtkX3D::index
@ index
Definition: vtkX3D.h:252
vtkObjectBase::UnRegister
virtual void UnRegister(vtkObjectBase *o)
Decrease the reference count (release by another object).
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkAlgorithm::AddInputDataInternal
void AddInputDataInternal(int port, vtkDataObject *input)
Definition: vtkAlgorithm.h:889
vtkAlgorithm::DesiredOutputPrecision
DesiredOutputPrecision
Values used for setting the desired output precision for various algorithms.
Definition: vtkAlgorithm.h:89
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:293