vtkSelection.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 vtkSelection_h
#define vtkSelection_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"
#include "vtkSmartPointer.h" // for  vtkSmartPointer.
 
#include <array>  // for array.
#include <string> // for string.
#include <vector> // for vector.
 
VTK_ABI_NAMESPACE_BEGIN
class vtkSelectionNode;
class vtkSignedCharArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkSelection : public vtkDataObject
{
public:
  vtkTypeMacro(vtkSelection, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkSelection* New();
 
  void Initialize() override;
 
  int GetDataObjectType() override { return VTK_SELECTION; }
 
  unsigned int GetNumberOfNodes() const;
 
  virtual vtkSelectionNode* GetNode(unsigned int idx) const;
 
  virtual vtkSelectionNode* GetNode(const std::string& name) const;
 
  virtual std::string AddNode(vtkSelectionNode*);
 
  virtual void SetNode(const std::string& name, vtkSelectionNode*);
 
  virtual std::string GetNodeNameAtIndex(unsigned int idx) const;
 
 
  virtual void RemoveNode(unsigned int idx);
  virtual void RemoveNode(const std::string& name);
  virtual void RemoveNode(vtkSelectionNode*);
 
  virtual void RemoveAllNodes();
 
 
  vtkSetMacro(Expression, std::string);
  vtkGetMacro(Expression, std::string);
 
  void DeepCopy(vtkDataObject* src) override;
 
  void ShallowCopy(vtkDataObject* src) override;
 
  virtual void Union(vtkSelection* selection);
 
  virtual void Union(vtkSelectionNode* node);
 
  virtual void Subtract(vtkSelection* selection);
 
  virtual void Subtract(vtkSelectionNode* node);
 
  vtkMTimeType GetMTime() override;
 
 
  virtual void Dump();
  virtual void Dump(ostream& os);
 
 
  static vtkSelection* GetData(vtkInformation* info);
  static vtkSelection* GetData(vtkInformationVector* v, int i = 0);
 
 
  vtkSmartPointer<vtkSignedCharArray> Evaluate(
    vtkSignedCharArray* const* values, unsigned int num_values) const
  {
    std::array<signed char, 2> range;
    return this->Evaluate(values, num_values, range);
  }
  vtkSmartPointer<vtkSignedCharArray> Evaluate(vtkSignedCharArray* const* values,
    unsigned int num_values, std::array<signed char, 2>& range) const;
 
 
  template <typename MapType>
  vtkSmartPointer<vtkSignedCharArray> Evaluate(const MapType& values_map) const
  {
    std::array<signed char, 2> range;
    return this->Evaluate(values_map, range);
  }
  template <typename MapType>
  vtkSmartPointer<vtkSignedCharArray> Evaluate(
    const MapType& values_map, std::array<signed char, 2>& range) const;
 
protected:
  vtkSelection();
  ~vtkSelection() override;
 
  std::string Expression;
 
private:
  vtkSelection(const vtkSelection&) = delete;
  void operator=(const vtkSelection&) = delete;
 
  class vtkInternals;
  vtkInternals* Internals;
  struct EvaluateFunctor;
};
 
//----------------------------------------------------------------------------
template <typename MapType>
inline vtkSmartPointer<vtkSignedCharArray> vtkSelection::Evaluate(
  const MapType& values_map, std::array<signed char, 2>& range) const
{
  const unsigned int num_nodes = this->GetNumberOfNodes();
  std::vector<vtkSignedCharArray*> values(num_nodes, nullptr);
  for (unsigned int cc = 0; cc < num_nodes; ++cc)
  {
    auto iter = values_map.find(this->GetNodeNameAtIndex(cc));
    values[cc] = iter != values_map.end() ? iter->second : nullptr;
  }
  return this->Evaluate(values.data(), num_nodes, range);
}
 
VTK_ABI_NAMESPACE_END
#endif