vtkGeometryFilterDispatcher.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkGeometryFilterDispatcher_h
#define vtkGeometryFilterDispatcher_h

#include "vtkDataObjectAlgorithm.h"
#include "vtkFiltersParallelModule.h" // needed for export macro
#include "vtkSmartPointer.h"          // needed for vtkSmartPointer

#include "vtkNew.h" // for vtkNew

VTK_ABI_NAMESPACE_BEGIN

class vtkCartesianGrid;
class vtkCellGrid;
class vtkDataSet;
class vtkDataObjectMeshCache;
class vtkDataObjectTree;
class vtkExplicitStructuredGrid;
class vtkFeatureEdges;
class vtkGenericDataSet;
class vtkGenericGeometryFilter;
class vtkGeometryFilter;
class vtkHyperTreeGrid;
class vtkImageData;
class vtkInformationIntegerVectorKey;
class vtkInformationVector;
class vtkMultiProcessController;
class vtkOutlineSource;
class vtkPolyData;
class vtkPolyDataNormals;
class vtkRecoverGeometryWireframe;
class vtkRectilinearGrid;
class vtkStructuredGrid;
class vtkUnstructuredGridBase;
class vtkUnstructuredGridGeometryFilter;

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


  vtkGetMacro(OutlineFlag, bool);


  vtkSetMacro(UseOutline, bool);
  vtkGetMacro(UseOutline, bool);
  vtkBooleanMacro(UseOutline, bool);


  void SetGenerateFeatureEdges(bool);
  vtkGetMacro(GenerateFeatureEdges, bool);


  vtkSetMacro(BlockColorsDistinctValues, int);
  vtkGetMacro(BlockColorsDistinctValues, int);


  void SetGenerateCellNormals(bool);
  vtkGetMacro(GenerateCellNormals, bool);
  vtkBooleanMacro(GenerateCellNormals, bool);


  void SetGeneratePointNormals(bool);
  vtkGetMacro(GeneratePointNormals, bool);
  vtkBooleanMacro(GeneratePointNormals, bool);


  void SetFeatureAngle(double);
  vtkGetMacro(FeatureAngle, double);


  void SetSplitting(bool);
  vtkGetMacro(Splitting, bool);
  vtkBooleanMacro(Splitting, bool);


  vtkSetMacro(Triangulate, bool);
  vtkGetMacro(Triangulate, bool);
  vtkBooleanMacro(Triangulate, bool);


  virtual void SetNonlinearSubdivisionLevel(int);
  vtkGetMacro(NonlinearSubdivisionLevel, int);


  virtual void SetMatchBoundariesIgnoringCellOrder(int);
  vtkGetMacro(MatchBoundariesIgnoringCellOrder, int);


  virtual void SetController(vtkMultiProcessController*);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);


  void SetPassThroughCellIds(bool);
  vtkGetMacro(PassThroughCellIds, bool);
  vtkBooleanMacro(PassThroughCellIds, bool);


  void SetPassThroughPointIds(bool);
  vtkGetMacro(PassThroughPointIds, bool);
  vtkBooleanMacro(PassThroughPointIds, bool);


  vtkSetMacro(GenerateProcessIds, bool);
  vtkGetMacro(GenerateProcessIds, bool);
  vtkBooleanMacro(GenerateProcessIds, bool);


  vtkSetMacro(HideInternalAMRFaces, bool);
  vtkGetMacro(HideInternalAMRFaces, bool);
  vtkBooleanMacro(HideInternalAMRFaces, bool);


  vtkSetMacro(UseNonOverlappingAMRMetaDataForOutlines, bool);
  vtkGetMacro(UseNonOverlappingAMRMetaDataForOutlines, bool);
  vtkBooleanMacro(UseNonOverlappingAMRMetaDataForOutlines, bool);

protected:
  vtkGeometryFilterDispatcher();
  ~vtkGeometryFilterDispatcher() override;


  int RequestDataObject(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  virtual int RequestAMRData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
  virtual int RequestDataObjectTree(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  void ExecuteAMRBlock(vtkCartesianGrid* input, vtkPolyData* output, const bool extractface[6]);

  void ExecuteAMRBlockOutline(
    const double bounds[6], vtkPolyData* output, const bool extractface[6]);

  void ExecuteBlock(vtkDataObject* input, vtkPolyData* output, bool doCommunicate, int updatePiece,
    int updateNumPieces, int updateGhosts, const int wholeExtent[6]);

  void DataSetExecute(vtkDataSet* input, vtkPolyData* output, bool doCommunicate);
  void GenericDataSetExecute(vtkGenericDataSet* input, vtkPolyData* output, bool doCommunicate);

  void ImageDataExecute(
    vtkImageData* input, vtkPolyData* output, bool doCommunicate, int updatePiece, const int* ext);

  void StructuredGridExecute(vtkStructuredGrid* input, vtkPolyData* output, int updatePiece,
    int updateNumPieces, int updateGhosts, const int wholeExtent[6]);

  void RectilinearGridExecute(vtkRectilinearGrid* input, vtkPolyData* output, int updatePiece,
    int updateNumPieces, int updateGhosts, const int wholeExtent[6]);

  void UnstructuredGridExecute(
    vtkUnstructuredGridBase* input, vtkPolyData* output, bool doCommunicate);

  void PolyDataExecute(vtkPolyData* input, vtkPolyData* output, bool doCommunicate);

  void HyperTreeGridExecute(vtkHyperTreeGrid* input, vtkPolyData* output, bool doCommunicate);

  void ExplicitStructuredGridExecute(vtkExplicitStructuredGrid* input, vtkPolyData* out,
    bool doCommunicate, const int wholeExtent[6]);

  void CellGridExecute(vtkCellGrid* input, vtkPolyData* output, bool doCommunicate);


  void CleanupOutputData(vtkPolyData* output);

  bool OutlineFlag = false;
  bool UseOutline = true;
  int BlockColorsDistinctValues = 7;
  bool GenerateCellNormals = false;
  bool GeneratePointNormals = false;
  bool Splitting = true;
  double FeatureAngle = 30.0;
  bool Triangulate = false;
  int NonlinearSubdivisionLevel = 1;
  int MatchBoundariesIgnoringCellOrder = 0;

  vtkMultiProcessController* Controller = nullptr;
  vtkSmartPointer<vtkOutlineSource> OutlineSource;
  vtkSmartPointer<vtkGeometryFilter> GeometryFilter;
  vtkSmartPointer<vtkGenericGeometryFilter> GenericGeometryFilter;
  vtkSmartPointer<vtkUnstructuredGridGeometryFilter> UnstructuredGridGeometryFilter;
  vtkSmartPointer<vtkRecoverGeometryWireframe> RecoverWireframeFilter;
  vtkSmartPointer<vtkFeatureEdges> FeatureEdgesFilter;
  vtkSmartPointer<vtkPolyDataNormals> PolyDataNormals;

  int CheckAttributes(vtkDataObject* input);

  // Callback for recording progress of internal filters.
  void HandleGeometryFilterProgress(vtkObject* caller, unsigned long, void*);

  int FillInputPortInformation(int, vtkInformation*) override;

  void ReportReferences(vtkGarbageCollector*) override;

  bool GenerateProcessIds = false;
  bool PassThroughCellIds = true;
  bool PassThroughPointIds = true;
  bool HideInternalAMRFaces = true;
  bool UseNonOverlappingAMRMetaDataForOutlines = true;
  bool GenerateFeatureEdges = false;

private:
  vtkGeometryFilterDispatcher(const vtkGeometryFilterDispatcher&) = delete;
  void operator=(const vtkGeometryFilterDispatcher&) = delete;

  void AddDataObjectTreeArrays(vtkDataObjectTree* realInput, vtkDataObjectTree* output);

  void AddCompositeIndex(vtkPolyData* pd, unsigned int index);

  void AddBlockColors(vtkDataObject* pd, unsigned int index);
  void AddHierarchicalIndex(vtkPolyData* pd, unsigned int level, unsigned int index);
  class BoundsReductionOperation;

  void GenerateFeatureEdgesHTG(vtkHyperTreeGrid* input, vtkPolyData* output);

  void ExecuteNormalsComputation(vtkPolyData* output);

  void GenerateProcessIdsArrays(vtkPolyData* output);

  bool UseCacheIfPossible(vtkDataObject* input, vtkDataObject* output);

  void UpdateCache(vtkDataObject* output);

  vtkSmartPointer<vtkDataObjectTree> GetDataObjectTreeInput(vtkInformationVector** inputVector);

  vtkNew<vtkDataObjectMeshCache> MeshCache;
};

VTK_ABI_NAMESPACE_END

#endif