vtkAlgorithm.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkAlgorithm.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 vtkAlgorithm_h
#define vtkAlgorithm_h
 
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkObject.h"
 
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 vtkAlgorithm : public vtkObject
{
public:
  static vtkAlgorithm *New();
  vtkTypeMacro(vtkAlgorithm,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  enum DesiredOutputPrecision
    {
    SINGLE_PRECISION,
    DOUBLE_PRECISION,
    DEFAULT_PRECISION
    };
 
  int HasExecutive();
 
  vtkExecutive* GetExecutive();
 
  virtual void SetExecutive(vtkExecutive* executive);
 
 
  virtual int ProcessRequest(vtkInformation* request,
                             vtkInformationVector** inInfo,
                             vtkInformationVector* outInfo);
 
 
  int ProcessRequest(vtkInformation* request,
                     vtkCollection* inInfo,
                     vtkInformationVector* outInfo);
 
 
  virtual int
  ComputePipelineMTime(vtkInformation* request,
                       vtkInformationVector** inInfoVec,
                       vtkInformationVector* outInfoVec,
                       int requestFromOutputPort,
                       unsigned long* 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();
 
 
  virtual void Register(vtkObjectBase* o);
  virtual void UnRegister(vtkObjectBase* o);
 
 
  vtkSetMacro(AbortExecute,int);
  vtkGetMacro(AbortExecute,int);
  vtkBooleanMacro(AbortExecute,int);
 
 
  vtkSetClampMacro(Progress,double,0.0,1.0);
  vtkGetMacro(Progress,double);
 
  void UpdateProgress(double amount);
 
 
  void SetProgressText(const char* ptext);
  vtkGetStringMacro(ProgressText);
 
 
  vtkGetMacro( ErrorCode, unsigned long );
 
  // left public for performance since it is used in inner loops
  int 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();
 
 
 
  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,
                              int fieldAttributeType);
  virtual void SetInputArrayToProcess(int idx, vtkInformation *info);
 
 
  virtual void SetInputArrayToProcess(int idx, int port, int connection,
                              const char* fieldAssociation,
                              const char* attributeTypeorName);
 
  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);
 
 
  virtual void Update(int port);
  virtual void Update();
 
 
  virtual void UpdateInformation();
 
  virtual void UpdateDataObject();
 
  virtual void PropagateUpdateExtent();
 
  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(int);
  virtual int GetReleaseDataFlag();
  void ReleaseDataFlagOn();
  void ReleaseDataFlagOff();
 
  //========================================================================
 
 
  int UpdateExtentIsEmpty(vtkInformation *pinfo, vtkDataObject *output);
  int UpdateExtentIsEmpty(vtkInformation *pinfo, int extentType);
 
  static void SetDefaultExecutivePrototype(vtkExecutive* proto);
 
  int SetUpdateExtentToWholeExtent(int port);
 
  int SetUpdateExtentToWholeExtent();
 
 
  void SetUpdateExtent(int port,
                       int piece,int numPieces, int ghostLevel);
 
 
  void SetUpdateExtent(int piece,int numPieces, int ghostLevel)
  {
    this->SetUpdateExtent(0, piece, numPieces, ghostLevel);
  }
 
  void SetUpdateExtent(int port, int extent[6]);
 
 
  void SetUpdateExtent(int extent[6])
  {
    this->SetUpdateExtent(0, extent);
  }
 
 
  int* GetUpdateExtent()
  {
    return this->GetUpdateExtent(0);
  }
  int* GetUpdateExtent(int port);
  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);
 
protected:
  vtkAlgorithm();
  ~vtkAlgorithm();
 
  // 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;
 
  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);
 
 
 
  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);
 
 
 
 
  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.
  virtual void ReportReferences(vtkGarbageCollector*);
 
  // 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);
 
private:
  vtkAlgorithm(const vtkAlgorithm&);  // Not implemented.
  void operator=(const vtkAlgorithm&);  // Not implemented.
};
 
#endif