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() VTK_FUTURE_CONST 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