vtkCellGrid.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 vtkCellGrid_h
#define vtkCellGrid_h
 
#include "vtkCellGridRangeQuery.h" // For RangeCache ivar.
#include "vtkCompiler.h"           // for VTK_COMPILER_MSVC
#include "vtkDataObject.h"
#include "vtkSmartPointer.h" // For ivars.
#include "vtkStringToken.h"  // For ivars.
#include "vtkTypeName.h"     // For vtk::TypeName<>().
 
#include <array>         // For ivars.
#include <set>           // For ivars.
#include <unordered_map> // For ivars.
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellAttribute;
class vtkCellGridQuery;
class vtkCellGridCopyQuery;
class vtkCellMetadata;
class vtkDataSetAttributes;
class vtkInformationIntegerVectorKey;
 
class VTKCOMMONDATAMODEL_EXPORT vtkCellGrid : public vtkDataObject
{
public:
  using CellTypeId = vtkStringToken;
 
  static vtkCellGrid* New();
 
  vtkTypeMacro(vtkCellGrid, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Initialize() override;
 
  int GetDataObjectType() override { return VTK_CELL_GRID; }
 
  unsigned long GetActualMemorySize() override;
 
  void ShallowCopy(vtkDataObject* baseSrc) override;
 
  void DeepCopy(vtkDataObject* baseSrc) override;
 
  bool CopyStructure(vtkCellGrid* other, bool byReference = true);
 
 
  vtkDataSetAttributes* GetAttributes(int type) override;
  vtkDataSetAttributes* GetAttributes(vtkStringToken type);
  vtkDataSetAttributes* FindAttributes(int type) const;
  vtkDataSetAttributes* FindAttributes(vtkStringToken type) const;
  const std::unordered_map<int, vtkSmartPointer<vtkDataSetAttributes>>& GetArrayGroups() const
  {
    return this->ArrayGroups;
  }
 
  void MapArrayLocations(
    std::unordered_map<vtkAbstractArray*, vtkStringToken>& arrayLocations) const;
 
  vtkUnsignedCharArray* GetGhostArray(int type) override;
 
  bool SupportsGhostArray(int type) override;
 
  int GetAttributeTypeForArray(vtkAbstractArray* arr) override;
 
  vtkIdType GetNumberOfElements(int type) override;
 
  vtkIdType GetNumberOfCells();
 
  void GetBounds(double bounds[6]);
 
 
  template <typename CellType>
  CellType* AddCellMetadata()
  {
    CellType* result = this->GetCellsOfType<CellType>();
    if (result)
    {
      return result;
    }
    auto metadata = vtkSmartPointer<CellType>::New();
    if (metadata->SetCellGrid(this))
    {
      auto ok = this->Cells.insert(
        std::make_pair(vtkStringToken(vtk::TypeName<CellType>()).GetId(), metadata));
      if (ok.second)
      {
        result = dynamic_cast<CellType*>(ok.first->second.GetPointer());
      }
    }
    return result;
  }
 
  vtkCellMetadata* AddCellMetadata(vtkCellMetadata* cellType);
 
  vtkCellMetadata* AddCellMetadata(vtkStringToken cellTypeName);
 
 
  int AddAllCellMetadata();
 
  template <typename CellType>
  bool RemoveCellMetadata()
  {
    CellType* meta = this->GetCellsOfType<CellType>();
    if (!meta)
    {
      return false;
    }
    return this->RemoveCellMetadata(meta);
  }
 
  bool RemoveCellMetadata(vtkCellMetadata* meta);
 
 
  int RemoveUnusedCellMetadata();
 
 
  template <typename CellType>
  const CellType* GetCellsOfType() const
  {
    auto it = this->Cells.find(vtkStringToken(vtk::TypeName<CellType>()).GetId());
    if (it == this->Cells.end())
    {
      return nullptr;
    }
    return static_cast<const CellType*>(it->second.GetPointer());
  }
  template <typename CellType>
  CellType* GetCellsOfType()
  {
    auto it = this->Cells.find(vtkStringToken(vtk::TypeName<CellType>()).GetId());
    if (it == this->Cells.end())
    {
      return nullptr;
    }
    return static_cast<CellType*>(it->second.GetPointer());
  }
 
 
  template <typename Container>
  void CellTypes(Container& cellTypes) const
  {
    for (const auto& entry : this->Cells)
    {
      cellTypes.insert(cellTypes.end(), entry.first);
    }
  }
  template <typename Container>
  Container CellTypes() const
  {
    Container cellTypes;
    this->CellTypes(cellTypes);
    return cellTypes;
  }
  std::vector<vtkStringToken> CellTypeArray() const
  {
#if defined(_MSC_VER) && _MSC_VER >= 1930 && _MSC_VER < 1940 /*17.4+*/
    // MSVC 2022 bombs when an exported method uses thread_local in its implementation.
    // See https://github.com/pytorch/pytorch/issues/87957 for more. We omit the
    // thread_local here, which makes this method non-threadsafe on Windows, which
    // should be OK in most cases.
    static std::vector<vtkStringToken> cellTypes;
#else
    static thread_local std::vector<vtkStringToken> cellTypes;
#endif
    cellTypes.clear();
    this->CellTypes(cellTypes);
    return cellTypes;
  }
  std::vector<std::string> GetCellTypes() const
  {
    auto cta = this->CellTypeArray();
    std::vector<std::string> result;
    result.reserve(cta.size());
    for (const auto& cellTypeToken : cta)
    {
      result.push_back(cellTypeToken.Data());
    }
    return result;
  }
 
 
  const vtkCellMetadata* GetCellType(vtkStringToken cellTypeName) const;
  vtkCellMetadata* GetCellType(vtkStringToken cellTypeName);
 
 
  virtual bool AddCellAttribute(vtkCellAttribute* attribute);
 
 
  virtual bool RemoveCellAttribute(vtkCellAttribute* attribute);
 
  virtual bool GetCellAttributeRange(vtkCellAttribute* attribute, int componentIndex,
    double range[2], bool finiteRange = false) const;
 
  vtkCellGridRangeQuery::CacheMap& GetRangeCache() const { return this->RangeCache; }
 
  void ClearRangeCache(const std::string& attributeName = std::string());
 
  std::set<int> GetCellAttributeIds() const;
  std::vector<int> GetUnorderedCellAttributeIds() const;
 
  std::vector<vtkSmartPointer<vtkCellAttribute>> GetCellAttributeList() const;
 
 
  vtkCellAttribute* GetCellAttribute(vtkStringToken::Hash hash);
 
 
  vtkCellAttribute* GetCellAttributeById(int attributeId);
  vtkCellAttribute* GetCellAttributeByName(const std::string& name);
 
 
  vtkCellAttribute* GetShapeAttribute();
  bool SetShapeAttribute(vtkCellAttribute* shape);
 
 
  bool Query(vtkCellGridQuery* query);
 
  virtual void SetSchema(vtkStringToken name, vtkTypeUInt32 version);
  vtkGetStringTokenMacro(SchemaName);
  vtkGetMacro(SchemaVersion, vtkTypeUInt32);
 
  vtkSetMacro(ContentVersion, vtkTypeUInt32);
  vtkGetMacro(ContentVersion, vtkTypeUInt32)
 
  
  static vtkCellGrid* GetData(vtkInformation* info);
  static vtkCellGrid* GetData(vtkInformationVector* v, int i = 0);
 
  static vtkDataArray* CorrespondingArray(
    vtkCellGrid* gridA, vtkDataArray* arrayA, vtkCellGrid* gridB);
 
  static vtkInformationIntegerVectorKey* ARRAY_GROUP_IDS();
 
protected:
  // Provide write access to this->NextAttribute:
  friend class vtkCellGridCopyQuery;
 
  vtkCellGrid();
  ~vtkCellGrid() override;
 
  bool ComputeBoundsInternal();
  bool ComputeRangeInternal(vtkCellAttribute* attribute, int component, bool finiteRange) const;
 
  std::unordered_map<int, vtkSmartPointer<vtkDataSetAttributes>> ArrayGroups;
  std::unordered_map<CellTypeId, vtkSmartPointer<vtkCellMetadata>> Cells;
  std::unordered_map<vtkStringToken::Hash, vtkSmartPointer<vtkCellAttribute>> Attributes;
  int NextAttribute = 0;
  vtkStringToken ShapeAttribute;
  bool HaveShape{ false };
 
  vtkStringToken SchemaName;
  vtkTypeUInt32 SchemaVersion{ 0 };
  vtkTypeUInt32 ContentVersion{ 0 };
 
  mutable std::array<double, 6> CachedBounds;
  mutable vtkTimeStamp CachedBoundsTime;
 
  mutable vtkCellGridRangeQuery::CacheMap RangeCache;
 
private:
  vtkCellGrid(const vtkCellGrid&) = delete;
  void operator=(const vtkCellGrid&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif