vtkSelectionSource.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 vtkSelectionSource_h
#define vtkSelectionSource_h

#include "vtkFiltersSourcesModule.h" // For export macro
#include "vtkSelectionAlgorithm.h"
#include "vtkSelectionNode.h" // For FieldType
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO

#include <memory> // for std::shared_ptr
#include <vector> // for std::vector

VTK_ABI_NAMESPACE_BEGIN
class VTKFILTERSSOURCES_EXPORT VTK_MARSHALAUTO vtkSelectionSource : public vtkSelectionAlgorithm
{
public:
  static vtkSelectionSource* New();
  vtkTypeMacro(vtkSelectionSource, vtkSelectionAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetNumberOfNodes(unsigned int numberOfNodes);
  unsigned int GetNumberOfNodes() { return static_cast<unsigned int>(this->NodesInfo.size()); }


  void RemoveNode(unsigned int idx);
  void RemoveNode(const char* name);

  virtual void RemoveAllNodes();


  vtkSetStdStringFromCharMacro(Expression);
  vtkGetCharFromStdStringMacro(Expression);


  enum FieldTypeOptions
  {
    FIELD_TYPE,
    ELEMENT_TYPE
  };
  vtkSetClampMacro(FieldTypeOption, int, FIELD_TYPE, ELEMENT_TYPE);
  virtual void SetFieldTypeOptionToFieldType() { this->SetFieldTypeOption(FIELD_TYPE); }
  virtual void SetFieldTypeOptionToElementType() { this->SetFieldTypeOption(ELEMENT_TYPE); }
  vtkGetMacro(FieldTypeOption, int);


  vtkSetClampMacro(FieldType, int, vtkSelectionNode::CELL, vtkSelectionNode::ROW);
  vtkGetMacro(FieldType, int);


  vtkSetClampMacro(ElementType, int, vtkDataObject::POINT, vtkDataObject::ROW);
  vtkGetMacro(ElementType, int);


  vtkSetClampMacro(ProcessID, int, -1, VTK_INT_MAX);
  vtkGetMacro(ProcessID, int);

  //------------------------------------------------------------------------------
  // Functions to manipulate the information of each selection node.
  //------------------------------------------------------------------------------


  void SetNodeName(unsigned int nodeId, const char* name);
  void SetNodeName(const char* name) { this->SetNodeName(0, name); }
  const char* GetNodeName(unsigned int nodeId);
  const char* GetNodeName() { return this->GetNodeName(0); }


  void AddID(unsigned int nodeId, vtkIdType piece, vtkIdType id);
  void AddID(vtkIdType piece, vtkIdType id) { this->AddID(0, piece, id); }
  void AddStringID(unsigned int nodeId, vtkIdType piece, const char* id);
  void AddStringID(vtkIdType piece, const char* id) { this->AddStringID(0, piece, id); }


  void AddLocation(unsigned int nodeId, double x, double y, double z);
  void AddLocation(double x, double y, double z) { this->AddLocation(0, x, y, z); }


  void AddThreshold(unsigned int nodeId, double min, double max);
  void AddThreshold(double min, double max) { this->AddThreshold(0, min, max); }


  void SetFrustum(unsigned int nodeId, double* vertices);
  void SetFrustum(double* vertices) { this->SetFrustum(0, vertices); }


  void AddBlock(unsigned int nodeId, vtkIdType block);
  void AddBlock(vtkIdType blockno) { this->AddBlock(0, blockno); }


  void AddBlockSelector(unsigned int nodeId, const char* block);
  void AddBlockSelector(const char* selector) { this->AddBlockSelector(0, selector); }
  void RemoveAllBlockSelectors(unsigned int nodeId);
  void RemoveAllBlockSelectors() { this->RemoveAllBlockSelectors(0); }


  void RemoveAllIDs(unsigned int nodeId);
  void RemoveAllIDs() { this->RemoveAllIDs(0); }
  void RemoveAllStringIDs(unsigned int nodeId);
  void RemoveAllStringIDs() { this->RemoveAllStringIDs(0); }


  void RemoveAllThresholds(unsigned int nodeId);
  void RemoveAllThresholds() { this->RemoveAllThresholds(0); }


  void RemoveAllLocations(unsigned int nodeId);
  void RemoveAllLocations() { this->RemoveAllLocations(0); }


  void RemoveAllBlocks(unsigned int nodeId);
  void RemoveAllBlocks() { this->RemoveAllBlocks(0); }


  void SetContentType(unsigned int nodeId, int type);
  void SetContentType(int contentType) { this->SetContentType(0, contentType); }
  int GetContentTypeMinValue() { return vtkSelectionNode::SelectionContent::GLOBALIDS; }
  int GetContentTypeMaxValue() { return vtkSelectionNode::SelectionContent::USER; }
  int GetContentType(unsigned int nodeId);
  int GetContentType() { return this->GetContentType(0); }


  void SetContainingCells(unsigned int nodeId, vtkTypeBool containingCells);
  void SetContainingCells(vtkTypeBool containingCells)
  {
    this->SetContainingCells(0, containingCells);
  }
  vtkTypeBool GetContainingCells(unsigned int nodeId);
  vtkTypeBool GetContainingCells() { return this->GetContainingCells(0); }


  void SetNumberOfLayers(unsigned int nodeId, int numberOfLayers);
  void SetNumberOfLayers(int numberOfLayers) { this->SetNumberOfLayers(0, numberOfLayers); }
  int GetNumberOfLayersMinValue() { return 0; }
  int GetNumberOfLayersMaxValue() { return VTK_INT_MAX; }
  int GetNumberOfLayers(unsigned int nodeId);
  int GetNumberOfLayers() { return this->GetNumberOfLayers(0); }


  void SetRemoveSeed(unsigned int nodeId, bool RemoveSeed);
  void SetRemoveSeed(bool RemoveSeed) { this->SetRemoveSeed(0, RemoveSeed); }
  bool GetRemoveSeed(unsigned int nodeId);
  bool GetRemoveSeed() { return this->GetRemoveSeed(0); }


  void SetRemoveIntermediateLayers(unsigned int nodeId, bool RemoveIntermediateLayers);
  void SetRemoveIntermediateLayers(bool RemoveIntermediateLayers)
  {
    this->SetRemoveIntermediateLayers(0, RemoveIntermediateLayers);
  }
  bool GetRemoveIntermediateLayers(unsigned int nodeId);
  bool GetRemoveIntermediateLayers() { return this->GetRemoveIntermediateLayers(0); }


  void SetInverse(unsigned int nodeId, vtkTypeBool inverse);
  void SetInverse(vtkTypeBool inverse) { this->SetInverse(0, inverse); }
  vtkTypeBool GetInverse(unsigned int nodeId);
  vtkTypeBool GetInverse() { return this->GetInverse(0); }


  void SetArrayName(unsigned int nodeId, const char* name);
  void SetArrayName(const char* name) { this->SetArrayName(0, name); }
  const char* GetArrayName(unsigned int nodeId);
  const char* GetArrayName() { return this->GetArrayName(0); }


  void SetArrayComponent(unsigned int nodeId, int component);
  void SetArrayComponent(int component) { this->SetArrayComponent(0, component); }
  int GetArrayComponent(unsigned int nodeId);
  int GetArrayComponent() { return this->GetArrayComponent(0); }


  void SetCompositeIndex(unsigned int nodeId, int index);
  void SetCompositeIndex(int compositeIndex) { this->SetCompositeIndex(0, compositeIndex); }
  int GetCompositeIndex(unsigned int nodeId);
  int GetCompositeIndex() { return this->GetCompositeIndex(0); }


  void SetHierarchicalLevel(unsigned int nodeId, int level);
  void SetHierarchicalLevel(int level) { this->SetHierarchicalLevel(0, level); }
  int GetHierarchicalLevel(unsigned int nodeId);
  int GetHierarchicalLevel() { return this->GetHierarchicalLevel(0); }
  void SetHierarchicalIndex(unsigned int nodeId, int index);
  void SetHierarchicalIndex(int index) { this->SetHierarchicalIndex(0, index); }
  int GetHierarchicalIndex(unsigned int nodeId);
  int GetHierarchicalIndex() { return this->GetHierarchicalIndex(0); }


  void SetAssemblyName(unsigned int nodeId, const char* name);
  void SetAssemblyName(const char* name) { this->SetAssemblyName(0, name); }
  const char* GetAssemblyName(unsigned int nodeId);
  const char* GetAssemblyName() { return this->GetAssemblyName(0); }
  void AddSelector(unsigned int nodeId, const char* selector);
  void AddSelector(const char* selector) { this->AddSelector(0, selector); }
  void RemoveAllSelectors(unsigned int nodeId);
  void RemoveAllSelectors() { this->RemoveAllSelectors(0); }


  void SetQueryString(unsigned int nodeId, const char* queryString);
  void SetQueryString(const char* query) { this->SetQueryString(0, query); }
  const char* GetQueryString(unsigned int nodeId);
  const char* GetQueryString() { return this->GetQueryString(0); }

protected:
  vtkSelectionSource();
  ~vtkSelectionSource() override;

  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  std::string Expression;
  int FieldTypeOption;
  int FieldType;
  int ElementType;
  int ProcessID;
  struct NodeInformation;
  std::vector<std::shared_ptr<NodeInformation>> NodesInfo;

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

VTK_ABI_NAMESPACE_END
#endif