GraphAlgorithmSource

#include <vtkSmartPointer.h>
#include <vtkGraph.h>
#include <vtkMutableUndirectedGraph.h>

#include "vtkTestGraphAlgorithmSource.h"

int main (int, char *[])
{
  vtkSmartPointer<vtkTestGraphAlgorithmSource> source =
    vtkSmartPointer<vtkTestGraphAlgorithmSource>::New();
  source->Update();

  vtkGraph* outputGraph = source->GetOutput();

  std::cout << "Output number of vertices: "
            << outputGraph->GetNumberOfVertices() << std::endl;

  return EXIT_SUCCESS;
}

#ifndef __vtkTestGraphAlgorithmSource_h
#define __vtkTestGraphAlgorithmSource_h

#include <vtkGraphAlgorithm.h>

class vtkTestGraphAlgorithmSource : public vtkGraphAlgorithm 
{
public:
  static vtkTestGraphAlgorithmSource *New();
  vtkTypeMacro(vtkTestGraphAlgorithmSource,vtkGraphAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

protected:
  vtkTestGraphAlgorithmSource();
  ~vtkTestGraphAlgorithmSource();

  int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override;

  int RequestDataObject(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override;

private:
  vtkTestGraphAlgorithmSource(const vtkTestGraphAlgorithmSource&);  // Not implemented.
  void operator=(const vtkTestGraphAlgorithmSource&);  // Not implemented.

};

#endif

#include "vtkTestGraphAlgorithmSource.h"

#include <vtkObjectFactory.h>
#include <vtkStreamingDemandDrivenPipeline.h>
#include <vtkInformationVector.h>
#include <vtkInformation.h>
#include <vtkDataObject.h>
#include <vtkSmartPointer.h>
#include <vtkMutableUndirectedGraph.h>
#include <vtkUndirectedGraph.h>
#include <vtkGraph.h>

vtkStandardNewMacro(vtkTestGraphAlgorithmSource);

vtkTestGraphAlgorithmSource::vtkTestGraphAlgorithmSource()
{
  this->SetNumberOfInputPorts(0);
  this->SetNumberOfOutputPorts(1);
}

vtkTestGraphAlgorithmSource::~vtkTestGraphAlgorithmSource()
{

}

int vtkTestGraphAlgorithmSource::RequestData(
  vtkInformation *vtkNotUsed(request),
  vtkInformationVector **vtkNotUsed(inputVector),
  vtkInformationVector *outputVector)
{

  vtkInformation *outInfo = outputVector->GetInformationObject(0);

  vtkGraph *output = dynamic_cast<vtkGraph*>(
    outInfo->Get(vtkDataObject::DATA_OBJECT()));

  vtkSmartPointer<vtkMutableUndirectedGraph> NewGraph =
    vtkSmartPointer<vtkMutableUndirectedGraph>::New();

  //add 3 vertices
  NewGraph->AddVertex();
  NewGraph->AddVertex();
  NewGraph->AddVertex();

  output->ShallowCopy(NewGraph);

  return 1;
}

int vtkTestGraphAlgorithmSource::RequestDataObject(
  vtkInformation*, 
  vtkInformationVector**, 
  vtkInformationVector* )
{

  vtkSmartPointer<vtkUndirectedGraph> output =
    vtkSmartPointer<vtkUndirectedGraph>::New();
  this->GetExecutive()->SetOutputData(0, output);

  return 1;
}

//----------------------------------------------------------------------------
void vtkTestGraphAlgorithmSource::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os,indent);
}

cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(GraphAlgorithmSource)

find_package(VTK COMPONENTS 
  vtkCommonCore
  vtkCommonDataModel QUIET)
if (NOT VTK_FOUND)
  message("Skipping GraphAlgorithmSource: ${VTK_NOT_FOUND_MESSAGE}")
  return ()
endif()
message (STATUS "VTK_VERSION: ${VTK_VERSION}")
if (VTK_VERSION VERSION_LESS "8.90.0")
  # old system
  include(${VTK_USE_FILE})
  add_executable(GraphAlgorithmSource MACOSX_BUNDLE GraphAlgorithmSource.cxx )
  target_link_libraries(GraphAlgorithmSource PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(GraphAlgorithmSource MACOSX_BUNDLE GraphAlgorithmSource.cxx )
  target_link_libraries(GraphAlgorithmSource PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS GraphAlgorithmSource
    MODULES ${VTK_LIBRARIES}
    )
endif () 

cd GraphAlgorithmSource/build 

cmake ..

cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

make

./GraphAlgorithmSource