vtkDataObjectToDataSetFilter.h

Go to the documentation of this file.

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

#include "vtkDataSetAlgorithm.h"
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkWrappingHints.h"     // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkDataArray;
class vtkDataSet;
class vtkPointSet;
class vtkPolyData;
class vtkRectilinearGrid;
class vtkStructuredGrid;
class vtkStructuredPoints;
class vtkUnstructuredGrid;

class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO vtkDataObjectToDataSetFilter
  : public vtkDataSetAlgorithm
{
public:
  static vtkDataObjectToDataSetFilter* New();
  vtkTypeMacro(vtkDataObjectToDataSetFilter, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  vtkDataObject* GetInput();


  void SetDataSetType(int);
  vtkGetMacro(DataSetType, int);
  void SetDataSetTypeToPolyData() { this->SetDataSetType(VTK_POLY_DATA); }
  void SetDataSetTypeToStructuredPoints() { this->SetDataSetType(VTK_STRUCTURED_POINTS); }
  void SetDataSetTypeToStructuredGrid() { this->SetDataSetType(VTK_STRUCTURED_GRID); }
  void SetDataSetTypeToRectilinearGrid() { this->SetDataSetType(VTK_RECTILINEAR_GRID); }
  void SetDataSetTypeToUnstructuredGrid() { this->SetDataSetType(VTK_UNSTRUCTURED_GRID); }


  vtkDataSet* GetOutput();
  vtkDataSet* GetOutput(int idx);
  vtkPolyData* GetPolyDataOutput();
  vtkStructuredPoints* GetStructuredPointsOutput();
  vtkStructuredGrid* GetStructuredGridOutput();
  vtkUnstructuredGrid* GetUnstructuredGridOutput();
  vtkRectilinearGrid* GetRectilinearGridOutput();


  void SetPointComponent(
    int comp, const char* arrayName, int arrayComp, int min, int max, int normalize);
  void SetPointComponent(int comp, const char* arrayName, int arrayComp)
  {
    this->SetPointComponent(comp, arrayName, arrayComp, -1, -1, this->DefaultNormalize);
  }
  const char* GetPointComponentArrayName(int comp);
  int GetPointComponentArrayComponent(int comp);
  int GetPointComponentMinRange(int comp);
  int GetPointComponentMaxRange(int comp);
  int GetPointComponentNormailzeFlag(int comp);


  void SetVertsComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetVertsComponent(const char* arrayName, int arrayComp)
  {
    this->SetVertsComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetVertsComponentArrayName();
  int GetVertsComponentArrayComponent();
  int GetVertsComponentMinRange();
  int GetVertsComponentMaxRange();
  void SetLinesComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetLinesComponent(const char* arrayName, int arrayComp)
  {
    this->SetLinesComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetLinesComponentArrayName();
  int GetLinesComponentArrayComponent();
  int GetLinesComponentMinRange();
  int GetLinesComponentMaxRange();
  void SetPolysComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetPolysComponent(const char* arrayName, int arrayComp)
  {
    this->SetPolysComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetPolysComponentArrayName();
  int GetPolysComponentArrayComponent();
  int GetPolysComponentMinRange();
  int GetPolysComponentMaxRange();
  void SetStripsComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetStripsComponent(const char* arrayName, int arrayComp)
  {
    this->SetStripsComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetStripsComponentArrayName();
  int GetStripsComponentArrayComponent();
  int GetStripsComponentMinRange();
  int GetStripsComponentMaxRange();


  void SetCellTypeComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetCellTypeComponent(const char* arrayName, int arrayComp)
  {
    this->SetCellTypeComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetCellTypeComponentArrayName();
  int GetCellTypeComponentArrayComponent();
  int GetCellTypeComponentMinRange();
  int GetCellTypeComponentMaxRange();
  void SetCellConnectivityComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetCellConnectivityComponent(const char* arrayName, int arrayComp)
  {
    this->SetCellConnectivityComponent(arrayName, arrayComp, -1, -1);
  }
  const char* GetCellConnectivityComponentArrayName();
  int GetCellConnectivityComponentArrayComponent();
  int GetCellConnectivityComponentMinRange();
  int GetCellConnectivityComponentMaxRange();


  vtkSetMacro(DefaultNormalize, vtkTypeBool);
  vtkGetMacro(DefaultNormalize, vtkTypeBool);
  vtkBooleanMacro(DefaultNormalize, vtkTypeBool);


  vtkSetVector3Macro(Dimensions, int);
  vtkGetVectorMacro(Dimensions, int, 3);


  vtkSetVector3Macro(Origin, double);
  vtkGetVectorMacro(Origin, double, 3);


  vtkSetVector3Macro(Spacing, double);
  vtkGetVectorMacro(Spacing, double, 3);


  void SetDimensionsComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetDimensionsComponent(const char* arrayName, int arrayComp)
  {
    this->SetDimensionsComponent(arrayName, arrayComp, -1, -1);
  }
  void SetSpacingComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetSpacingComponent(const char* arrayName, int arrayComp)
  {
    this->SetSpacingComponent(arrayName, arrayComp, -1, -1);
  }
  void SetOriginComponent(const char* arrayName, int arrayComp, int min, int max);
  void SetOriginComponent(const char* arrayName, int arrayComp)
  {
    this->SetOriginComponent(arrayName, arrayComp, -1, -1);
  }

protected:
  vtkDataObjectToDataSetFilter();
  ~vtkDataObjectToDataSetFilter() override;

  int RequestData(vtkInformation*, vtkInformationVector**,
    vtkInformationVector*) override; // generate output data
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestDataObject(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  char Updating;

  // control flags used to generate the output dataset
  int DataSetType; // the type of dataset to generate

  // Support definition of points
  char* PointArrays[3];                // the name of the arrays
  int PointArrayComponents[3];         // the array components used for x-y-z
  vtkIdType PointComponentRange[3][2]; // the range of the components to use
  int PointNormalize[3];               // flags control normalization

  // These define cells for vtkPolyData
  char* VertsArray;                 // the name of the array
  int VertsArrayComponent;          // the array component
  vtkIdType VertsComponentRange[2]; // the range of the components to use

  char* LinesArray;                 // the name of the array
  int LinesArrayComponent;          // the array component used for cell types
  vtkIdType LinesComponentRange[2]; // the range of the components to use

  char* PolysArray;                 // the name of the array
  int PolysArrayComponent;          // the array component
  vtkIdType PolysComponentRange[2]; // the range of the components to use

  char* StripsArray;                 // the name of the array
  int StripsArrayComponent;          // the array component
  vtkIdType StripsComponentRange[2]; // the range of the components to use

  // Used to define vtkUnstructuredGrid datasets
  char* CellTypeArray;                 // the name of the array
  int CellTypeArrayComponent;          // the array component used for cell types
  vtkIdType CellTypeComponentRange[2]; // the range of the components to use

  char* CellConnectivityArray;                 // the name of the array
  int CellConnectivityArrayComponent;          // the array components used for cell connectivity
  vtkIdType CellConnectivityComponentRange[2]; // the range of the components to use

  // helper methods (and attributes) to construct datasets
  void SetArrayName(char*& name, char* newName);
  vtkIdType ConstructPoints(vtkDataObject* input, vtkPointSet* ps);
  vtkIdType ConstructPoints(vtkDataObject* input, vtkRectilinearGrid* rg);
  int ConstructCells(vtkDataObject* input, vtkPolyData* pd);
  int ConstructCells(vtkDataObject* input, vtkUnstructuredGrid* ug);
  vtkCellArray* ConstructCellArray(vtkDataArray* da, int comp, vtkIdType compRange[2]);

  // Default value for normalization
  vtkTypeBool DefaultNormalize;

  // Couple of different ways to specify dimensions, spacing, and origin.
  int Dimensions[3];
  double Origin[3];
  double Spacing[3];

  char* DimensionsArray;                 // the name of the array
  int DimensionsArrayComponent;          // the component of the array used for dimensions
  vtkIdType DimensionsComponentRange[2]; // the ComponentRange of the array for the dimensions

  char* OriginArray;                 // the name of the array
  int OriginArrayComponent;          // the component of the array used for Origins
  vtkIdType OriginComponentRange[2]; // the ComponentRange of the array for the Origins

  char* SpacingArray;                 // the name of the array
  int SpacingArrayComponent;          // the component of the array used for Spacings
  vtkIdType SpacingComponentRange[2]; // the ComponentRange of the array for the Spacings

  void ConstructDimensions(vtkDataObject* input);
  void ConstructSpacing(vtkDataObject* input);
  void ConstructOrigin(vtkDataObject* input);

private:
  vtkDataObjectToDataSetFilter(const vtkDataObjectToDataSetFilter&) = delete;
  void operator=(const vtkDataObjectToDataSetFilter&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif