VTK/Examples/Developers/vtkAlgorithm Source

#include <vtkSmartPointer.h>
 
#include "vtkTestSource.h"
#include "vtkTest.h"
 
int main(int, char *[])
{
  vtkTestSource* source = vtkTestSource::New();
  source->Update();
 
  vtkTest* test = source->GetOutput();
  std::cout << test->GetValue() << std::endl;
 
  return EXIT_SUCCESS;
}

#ifndef __vtkTestSource_h
#define __vtkTestSource_h
 
#include "vtkAlgorithm.h"
 
class vtkDataSet;
class vtkTest;
 
class vtkTestSource : public vtkAlgorithm
{
  public:
    static vtkTestSource *New();
    vtkTypeRevisionMacro(vtkTestSource,vtkAlgorithm);
    void PrintSelf(ostream& os, vtkIndent indent);
 
  // Description:
  // Get the output data object for a port on this algorithm.
    vtkTest* GetOutput();
    vtkTest* GetOutput(int);
    virtual void SetOutput(vtkDataObject* d);
 
  // Description:
  // see vtkAlgorithm for details
    virtual int ProcessRequest(vtkInformation*,
                               vtkInformationVector**,
                               vtkInformationVector*);
 
  protected:
    vtkTestSource();
    ~vtkTestSource();
 
  // Description:
  // This is called by the superclass.
  // This is the method you should override.
    virtual int RequestDataObject(
                                  vtkInformation* request,
                                  vtkInformationVector** inputVector,
                                  vtkInformationVector* outputVector );
 
  // convenience method
    virtual int RequestInformation(
                                   vtkInformation* request,
                                   vtkInformationVector** inputVector,
                                   vtkInformationVector* outputVector );
 
  // Description:
  // This is called by the superclass.
  // This is the method you should override.
    virtual int RequestData(
                            vtkInformation* request,
                            vtkInformationVector** inputVector,
                            vtkInformationVector* outputVector );
 
  // Description:
  // This is called by the superclass.
  // This is the method you should override.
    virtual int RequestUpdateExtent(
                                    vtkInformation*,
                                    vtkInformationVector**,
                                    vtkInformationVector* );
 
    virtual int FillOutputPortInformation( int port, vtkInformation* info );
 
  private:
    vtkTestSource( const vtkTestSource& ); // Not implemented.
    void operator = ( const vtkTestSource& );  // Not implemented.
};
 
#endif

#include "vtkTestSource.h"
#include "vtkTest.h"
 
#include "vtkCommand.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkObjectFactory.h"
#include "vtkStreamingDemandDrivenPipeline.h"
 
vtkCxxRevisionMacro(vtkTestSource, "$Revision: 1.1 $");
vtkStandardNewMacro(vtkTestSource);
 
//----------------------------------------------------------------------------
vtkTestSource::vtkTestSource()
{
  this->SetNumberOfInputPorts( 0 );
  this->SetNumberOfOutputPorts( 1 );
}
 
//----------------------------------------------------------------------------
vtkTestSource::~vtkTestSource()
{
}
 
//----------------------------------------------------------------------------
void vtkTestSource::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
}
 
//----------------------------------------------------------------------------
vtkTest* vtkTestSource::GetOutput()
{
  return this->GetOutput(0);
}
 
//----------------------------------------------------------------------------
vtkTest* vtkTestSource::GetOutput(int port)
{
  return vtkTest::SafeDownCast(this->GetOutputDataObject(port));
}
 
//----------------------------------------------------------------------------
void vtkTestSource::SetOutput(vtkDataObject* d)
{
  this->GetExecutive()->SetOutputData(0, d);
}
 
 
//----------------------------------------------------------------------------
int vtkTestSource::ProcessRequest(vtkInformation* request,
                                     vtkInformationVector** inputVector,
                                     vtkInformationVector* outputVector)
{
  // Create an output object of the correct type.
  if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA_OBJECT()))
  {
    return this->RequestDataObject(request, inputVector, outputVector);
  }
  // generate the data
  if(request->Has(vtkDemandDrivenPipeline::REQUEST_DATA()))
  {
    return this->RequestData(request, inputVector, outputVector);
  }
 
  if(request->Has(vtkStreamingDemandDrivenPipeline::REQUEST_UPDATE_EXTENT()))
  {
    return this->RequestUpdateExtent(request, inputVector, outputVector);
  }
 
  // execute information
  if(request->Has(vtkDemandDrivenPipeline::REQUEST_INFORMATION()))
  {
    return this->RequestInformation(request, inputVector, outputVector);
  }
 
  return this->Superclass::ProcessRequest(request, inputVector, outputVector);
}
 
//----------------------------------------------------------------------------
int vtkTestSource::FillOutputPortInformation(
    int vtkNotUsed(port), vtkInformation* info)
{
  // now add our info
  info->Set(vtkDataObject::DATA_TYPE_NAME(), "vtkTest");
  return 1;
}
 
 
//----------------------------------------------------------------------------
int vtkTestSource::RequestDataObject(
                                        vtkInformation* vtkNotUsed(request),
    vtkInformationVector** vtkNotUsed(inputVector),
                                      vtkInformationVector* outputVector )
{
  for ( int i = 0; i < this->GetNumberOfOutputPorts(); ++i )
  {
    vtkInformation* outInfo = outputVector->GetInformationObject( i );
    vtkTest* output = vtkTest::SafeDownCast(
                                            outInfo->Get( vtkDataObject::DATA_OBJECT() ) );
    if ( ! output )
    {
      output = vtkTest::New();
      outInfo->Set( vtkDataObject::DATA_OBJECT(), output );
      output->FastDelete();
      output->SetPipelineInformation( outInfo );
      this->GetOutputPortInformation( i )->Set(
                                      vtkDataObject::DATA_EXTENT_TYPE(), output->GetExtentType() );
    }
  }
  return 1;
}
 
//----------------------------------------------------------------------------
int vtkTestSource::RequestInformation(
                                         vtkInformation* vtkNotUsed(request),
    vtkInformationVector** vtkNotUsed(inputVector),
                                      vtkInformationVector* vtkNotUsed(outputVector))
{
  // do nothing let subclasses handle it
  return 1;
}
 
//----------------------------------------------------------------------------
int vtkTestSource::RequestUpdateExtent(
                                          vtkInformation* vtkNotUsed(request),
    vtkInformationVector** inputVector,
    vtkInformationVector* vtkNotUsed(outputVector))
{
  int numInputPorts = this->GetNumberOfInputPorts();
  for (int i=0; i<numInputPorts; i++)
  {
    int numInputConnections = this->GetNumberOfInputConnections(i);
    for (int j=0; j<numInputConnections; j++)
    {
      vtkInformation* inputInfo = inputVector[i]->GetInformationObject(j);
      inputInfo->Set(vtkStreamingDemandDrivenPipeline::EXACT_EXTENT(), 1);
    }
  }
  return 1;
}
 
//----------------------------------------------------------------------------
// This is the superclasses style of Execute method.  Convert it into
// an imaging style Execute method.
int vtkTestSource::RequestData(
                                  vtkInformation* vtkNotUsed(request),
    vtkInformationVector** vtkNotUsed( inputVector ),
                                       vtkInformationVector* vtkNotUsed(outputVector) )
{
  // do nothing let subclasses handle it
  return 1;
}

#ifndef __vtkTest_h
#define __vtkTest_h
 
#include "vtkDataObject.h"
 
class vtkTest : public vtkDataObject
{
  public:
    static vtkTest* New();
    vtkTypeRevisionMacro(vtkTest,vtkDataObject);
    void PrintSelf( ostream& os, vtkIndent indent );
 
    vtkGetMacro(Value, double);
 
  protected:
    vtkTest();
    ~vtkTest();
 
  private:
    vtkTest( const vtkTest& ); // Not implemented.
    void operator = ( const vtkTest& ); // Not implemented.
 
    double Value;
};
 
#endif

#include "vtkTest.h"
 
#include "vtkObjectFactory.h"
 
vtkStandardNewMacro(vtkTest);
vtkCxxRevisionMacro(vtkTest,"$Revision: 1.46 $");
 
vtkTest::vtkTest()
{
  this->Value = 4.5;
}
 
vtkTest::~vtkTest()
{
 
}
 
void vtkTest::PrintSelf( ostream& os, vtkIndent indent )
{
  this->Superclass::PrintSelf( os, indent );
}