vtkCompositeDataPipeline.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCompositeDataPipeline.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 vtkCompositeDataPipeline_h
#define vtkCompositeDataPipeline_h
 
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkStreamingDemandDrivenPipeline.h"
#include <vtkSmartPointer.h> // smart pointer
 
#include <vector> // for vector in return type
 
class vtkCompositeDataSet;
class vtkCompositeDataIterator;
class vtkInformationDoubleKey;
class vtkInformationIntegerVectorKey;
class vtkInformationObjectBaseKey;
class vtkInformationStringKey;
class vtkInformationDataObjectKey;
class vtkInformationIntegerKey;
 
class VTKCOMMONEXECUTIONMODEL_EXPORT vtkCompositeDataPipeline
  : public vtkStreamingDemandDrivenPipeline
{
public:
  static vtkCompositeDataPipeline* New();
  vtkTypeMacro(vtkCompositeDataPipeline, vtkStreamingDemandDrivenPipeline);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkDataObject* GetCompositeOutputData(int port);
 
  vtkDataObject* GetCompositeInputData(int port, int index, vtkInformationVector** inInfoVec);
 
  static vtkInformationIntegerKey* LOAD_REQUESTED_BLOCKS();
 
  static vtkInformationObjectBaseKey* COMPOSITE_DATA_META_DATA();
 
  static vtkInformationIntegerVectorKey* UPDATE_COMPOSITE_INDICES();
 
  static vtkInformationDoubleKey* BLOCK_AMOUNT_OF_DETAIL();
 
protected:
  vtkCompositeDataPipeline();
  ~vtkCompositeDataPipeline() override;
 
  int ForwardUpstream(vtkInformation* request) override;
  virtual int ForwardUpstream(int i, int j, vtkInformation* request);
 
  // Copy information for the given request.
  void CopyDefaultInformation(vtkInformation* request, int direction,
    vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec) override;
 
  virtual void PushInformation(vtkInformation*);
  virtual void PopInformation(vtkInformation*);
 
  int ExecuteDataObject(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo) override;
 
  int ExecuteData(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec) override;
 
  void ExecuteDataStart(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec) override;
 
  // Override this check to account for update extent.
  int NeedToExecuteData(
    int outputPort, vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec) override;
 
  // Check whether the data object in the pipeline information exists
  // and has a valid type.
  virtual int CheckCompositeData(
    vtkInformation* request, vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec);
 
  // True when the pipeline is iterating over the current (simple) filter
  // to produce composite output. In this case, ExecuteDataStart() should
  // NOT Initialize() the composite output.
  int InLocalLoop;
 
  virtual void ExecuteSimpleAlgorithm(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec, int compositePort);
 
  virtual void ExecuteEach(vtkCompositeDataIterator* iter, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec, int compositePort, int connection, vtkInformation* request,
    std::vector<vtkSmartPointer<vtkCompositeDataSet> >& compositeOutput);
 
  std::vector<vtkDataObject*> ExecuteSimpleAlgorithmForBlock(vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec, vtkInformation* inInfo, vtkInformation* request,
    vtkDataObject* dobj);
 
  bool ShouldIterateOverInput(vtkInformationVector** inInfoVec, int& compositePort);
 
  int InputTypeIsValid(int port, int index, vtkInformationVector** inInfoVec) override;
 
  vtkInformation* InformationCache;
 
  vtkInformation* GenericRequest;
  vtkInformation* InformationRequest;
 
  void ResetPipelineInformation(int port, vtkInformation*) override;
 
  std::vector<vtkSmartPointer<vtkDataObject> > CreateOutputCompositeDataSet(
    vtkCompositeDataSet* input, int compositePort, int numOutputPorts);
 
  // Override this to handle UPDATE_COMPOSITE_INDICES().
  void MarkOutputsGenerated(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec) override;
 
  int NeedToExecuteBasedOnCompositeIndices(vtkInformation* outInfo);
 
  // Because we sometimes have to swap between "simple" data types and composite
  // data types, we sometimes want to skip resetting the pipeline information.
  static vtkInformationIntegerKey* SUPPRESS_RESET_PI();
 
  static vtkInformationIntegerVectorKey* DATA_COMPOSITE_INDICES();
 
private:
  vtkCompositeDataPipeline(const vtkCompositeDataPipeline&) = delete;
  void operator=(const vtkCompositeDataPipeline&) = delete;
};
 
#endif