vtkPolyhedronCellArray.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 vtkPolyhedronCellArray_h
#define vtkPolyhedronCellArray_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
 
#include "vtkCellArray.h"     // Needed for inline methods
#include "vtkIdList.h"        // Needed for inline methods
#include "vtkSmartPointer.h"  // For vtkSmartPointer
#include "vtkWrappingHints.h" // For VTK_EXPECTS, VTK_MARSHALMANUAL, VTK_WRAPEXCLUDE
 
#include <type_traits> // Needed for std::is_base_of_v
#include <utility>     // Needed for std::forward
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIdTypeArray;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkPolyhedronCellArray : public vtkObject
{
public:
  using AOSArray32 = vtkCellArray::AOSArray32;
  using AOSArray64 = vtkCellArray::AOSArray64;
  using AffineArray32 = vtkCellArray::AffineArray32;
  using AffineArray64 = vtkCellArray::AffineArray64;
  using StorageTypes = vtkCellArray::StorageTypes;
  using DispatchUtilities = vtkCellArray::DispatchUtilities;


  static vtkPolyhedronCellArray* New();
  vtkTypeMacro(vtkPolyhedronCellArray, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  bool AllocateEstimate(vtkIdType numCells, vtkIdType maxFacesPerCell, vtkIdType maxFacePoints);

  void Initialize();

  void Reset();

  void Squeeze();

  unsigned long GetActualMemorySize() const;

  void DeepCopy(vtkPolyhedronCellArray* other);

  void ShallowCopy(vtkPolyhedronCellArray* other);

  void SetData(vtkCellArray* faces, vtkCellArray* faceLocations);


  vtkCellArray* GetFaces() const { return this->Faces; }
  vtkCellArray* GetFaceLocations() const { return this->FaceLocations; }

  vtkMTimeType GetMTime() override;


  vtkIdType GetNumberOfCells() const { return this->FaceLocations->GetNumberOfCells(); }
  vtkIdType GetNumberOfFaces() const { return this->Faces->GetNumberOfCells(); }

  int GetMaxCellNumberOfFaces() const { return this->FaceLocations->GetMaxCellSize(); }

  int GetMaxFaceSize() const { return this->Faces->GetMaxCellSize(); }

  StorageTypes GetStorageType() const noexcept
  {
    const StorageTypes storageType = this->Faces->GetStorageType();
    return storageType == this->FaceLocations->GetStorageType() ? storageType
                                                                : StorageTypes::Generic;
  }

  bool IsStorageShareable() const { return this->Faces->IsStorageShareable(); }


  bool ConvertTo64BitStorage();
  bool ConvertTo32BitStorage();
  bool ConvertToDefaultStorage();
  bool ConvertToSmallestStorage();

  int GetCellNumberOfFaces(vtkIdType cellId) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  vtkIdType GetFaceId(vtkIdType cellId, int face) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  vtkIdType GetFaceSize(vtkIdType cellId, int face) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  vtkIdType GetCellNumberOfFacePoints(vtkIdType cellId) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  void GetFacePoints(vtkIdType cellId, int face, vtkIdType& npts,
    vtkIdType const*& pts VTK_SIZEHINT(npts), vtkIdList* tempIds) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  void GetFacePoints(vtkIdType cellId, int face, vtkIdList* pts) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  void GetFaceStream(vtkIdType cellId, vtkIdList* faceStream) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  void GetCellFaces(vtkIdType cellId, vtkCellArray* faces) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  VTK_WRAPEXCLUDE vtkIdType InsertNextCell(vtkIdType numFaces, const vtkIdType* faceStream);

  vtkIdType InsertNextCell(vtkCellArray* faces);

  vtkIdType InsertEmptyCells(vtkIdType numCells);

  void Append(vtkPolyhedronCellArray* source, vtkIdType pointOffset = 0);

  void ExportLegacyFormat(vtkIdTypeArray* faces, vtkIdTypeArray* faceLocations);


  bool ImportLegacyFormat(vtkIdTypeArray* faces, vtkIdTypeArray* faceLocations);
  bool ImportLegacyFormat(const vtkIdType* faces, vtkIdType facesLength,
    const vtkIdType* faceLocations, vtkIdType numberOfCells) VTK_SIZEHINT(faces, facesLength)
    VTK_SIZEHINT(faceLocations, numberOfCells);


  bool AppendLegacyFormat(
    vtkIdTypeArray* faces, vtkIdTypeArray* faceLocations, vtkIdType ptOffset = 0);
  bool AppendLegacyFormat(const vtkIdType* faces, vtkIdType facesLength,
    const vtkIdType* faceLocations, vtkIdType numberOfCells, vtkIdType ptOffset = 0)
    VTK_SIZEHINT(faces, facesLength) VTK_SIZEHINT(faceLocations, numberOfCells);

  template <typename Functor, typename... Args>
  decltype(auto) Dispatch(Functor&& functor, Args&&... args) const
  {
    return this->Dispatch(
      std::forward<Functor>(functor), this->GetStorageType(), std::forward<Args>(args)...);
  }
  template <typename Functor, typename... Args>
  decltype(auto) Dispatch(Functor&& functor, StorageTypes storageType, Args&&... args) const
  {
    vtkCellArray* faces = this->Faces;
    vtkCellArray* locations = this->FaceLocations;
    switch (storageType)
    {
      case StorageTypes::Int32:
        return functor(static_cast<AOSArray32*>(faces->GetOffsetsArray()),
          static_cast<AOSArray32*>(faces->GetConnectivityArray()),
          static_cast<AOSArray32*>(locations->GetOffsetsArray()),
          static_cast<AOSArray32*>(locations->GetConnectivityArray()), std::forward<Args>(args)...);
      case StorageTypes::Int64:
        return functor(static_cast<AOSArray64*>(faces->GetOffsetsArray()),
          static_cast<AOSArray64*>(faces->GetConnectivityArray()),
          static_cast<AOSArray64*>(locations->GetOffsetsArray()),
          static_cast<AOSArray64*>(locations->GetConnectivityArray()), std::forward<Args>(args)...);
      case StorageTypes::FixedSizeInt32:
        return functor(static_cast<AffineArray32*>(faces->GetOffsetsArray()),
          static_cast<AOSArray32*>(faces->GetConnectivityArray()),
          static_cast<AffineArray32*>(locations->GetOffsetsArray()),
          static_cast<AOSArray32*>(locations->GetConnectivityArray()), std::forward<Args>(args)...);
      case StorageTypes::FixedSizeInt64:
        return functor(static_cast<AffineArray64*>(faces->GetOffsetsArray()),
          static_cast<AOSArray64*>(faces->GetConnectivityArray()),
          static_cast<AffineArray64*>(locations->GetOffsetsArray()),
          static_cast<AOSArray64*>(locations->GetConnectivityArray()), std::forward<Args>(args)...);
      case StorageTypes::Generic:
      default:
        return functor(faces->GetOffsetsArray(), faces->GetConnectivityArray(),
          locations->GetOffsetsArray(), locations->GetConnectivityArray(),
          std::forward<Args>(args)...);
    }
  }
 
protected:
  vtkPolyhedronCellArray();
  ~vtkPolyhedronCellArray() override;
 
private:
  vtkPolyhedronCellArray(const vtkPolyhedronCellArray&) = delete;
  void operator=(const vtkPolyhedronCellArray&) = delete;
 
  vtkSmartPointer<vtkCellArray> Faces;
  vtkSmartPointer<vtkCellArray> FaceLocations;
};
VTK_ABI_NAMESPACE_END
 
namespace vtkPolyhedronCellArray_detail
{
VTK_ABI_NAMESPACE_BEGIN
struct GetCellNumberOfFacesImpl : public vtkPolyhedronCellArray::DispatchUtilities
{
  template <class FaceOffsetsT, class FaceConnectivityT, class LocationOffsetsT,
    class LocationConnectivityT>
  int operator()(FaceOffsetsT*, FaceConnectivityT*, LocationOffsetsT* locationOffsets,
    LocationConnectivityT*, vtkIdType cellId) const
  {
    return static_cast<int>(
      GetEndOffset(locationOffsets, cellId) - GetBeginOffset(locationOffsets, cellId));
  }
};
 
// The id, in Faces, of the face `face` of the cell cellId.
template <class LocationOffsetsT, class LocationConnectivityT>
vtkIdType GetFaceId(LocationOffsetsT* locationOffsets, LocationConnectivityT* locationConnectivity,
  vtkIdType cellId, int face)
{
  using Utilities = vtkPolyhedronCellArray::DispatchUtilities;
  return static_cast<vtkIdType>(Utilities::GetRange(
    locationConnectivity)[Utilities::GetBeginOffset(locationOffsets, cellId) + face]);
}
 
struct GetFaceIdImpl
{
  template <class FaceOffsetsT, class FaceConnectivityT, class LocationOffsetsT,
    class LocationConnectivityT>
  vtkIdType operator()(FaceOffsetsT*, FaceConnectivityT*, LocationOffsetsT* locationOffsets,
    LocationConnectivityT* locationConnectivity, vtkIdType cellId, int face) const
  {
    return GetFaceId(locationOffsets, locationConnectivity, cellId, face);
  }
};
 
struct GetFaceSizeImpl : public vtkPolyhedronCellArray::DispatchUtilities
{
  template <class FaceOffsetsT, class FaceConnectivityT, class LocationOffsetsT,
    class LocationConnectivityT>
  vtkIdType operator()(FaceOffsetsT* faceOffsets, FaceConnectivityT*,
    LocationOffsetsT* locationOffsets, LocationConnectivityT* locationConnectivity,
    vtkIdType cellId, int face) const
  {
    const vtkIdType faceId = GetFaceId(locationOffsets, locationConnectivity, cellId, face);
    return GetEndOffset(faceOffsets, faceId) - GetBeginOffset(faceOffsets, faceId);
  }
};
 
struct GetFacePointsImpl : public vtkPolyhedronCellArray::DispatchUtilities
{
  // Points pts at the points of the face, copied into tempIds unless they are shared, and returns
  // their number.
  template <class FaceOffsetsT, class FaceConnectivityT, class LocationOffsetsT,
    class LocationConnectivityT>
  vtkIdType operator()(FaceOffsetsT* faceOffsets, FaceConnectivityT* faceConnectivity,
    LocationOffsetsT* locationOffsets, LocationConnectivityT* locationConnectivity,
    vtkIdType cellId, int face, vtkIdType const*& pts, vtkIdList* tempIds) const
  {
    const vtkIdType faceId = GetFaceId(locationOffsets, locationConnectivity, cellId, face);
    const vtkIdType begin = GetBeginOffset(faceOffsets, faceId);
    const vtkIdType npts = GetEndOffset(faceOffsets, faceId) - begin;
    if constexpr (std::is_base_of_v<vtkAOSDataArrayTemplate<vtkIdType>, FaceConnectivityT>)
    {
      // The points are shared, as by vtkCellArray::GetCellAtId().
      pts = faceConnectivity->GetPointer(begin);
    }
    else
    {
      tempIds->SetNumberOfIds(npts);
      vtkIdType* ids = tempIds->GetPointer(0);
      const auto facePoints = GetRange(faceConnectivity).begin() + begin;
      for (vtkIdType i = 0; i < npts; ++i)
      {
        ids[i] = static_cast<vtkIdType>(facePoints[i]);
      }
      pts = ids;
    }
    return npts;
  }
};
VTK_ABI_NAMESPACE_END
} // namespace vtkPolyhedronCellArray_detail
 
VTK_ABI_NAMESPACE_BEGIN
 
//----------------------------------------------------------------------------
inline int vtkPolyhedronCellArray::GetCellNumberOfFaces(vtkIdType cellId) const
{
  return this->Dispatch(vtkPolyhedronCellArray_detail::GetCellNumberOfFacesImpl{}, cellId);
}
 
//----------------------------------------------------------------------------
inline vtkIdType vtkPolyhedronCellArray::GetFaceId(vtkIdType cellId, int face) const
{
  return this->Dispatch(vtkPolyhedronCellArray_detail::GetFaceIdImpl{}, cellId, face);
}
 
//----------------------------------------------------------------------------
inline vtkIdType vtkPolyhedronCellArray::GetFaceSize(vtkIdType cellId, int face) const
{
  return this->Dispatch(vtkPolyhedronCellArray_detail::GetFaceSizeImpl{}, cellId, face);
}
 
//----------------------------------------------------------------------------
inline void vtkPolyhedronCellArray::GetFacePoints(
  vtkIdType cellId, int face, vtkIdType& npts, vtkIdType const*& pts, vtkIdList* tempIds) const
{
  npts =
    this->Dispatch(vtkPolyhedronCellArray_detail::GetFacePointsImpl{}, cellId, face, pts, tempIds);
}
 
VTK_ABI_NAMESPACE_END
#endif // vtkPolyhedronCellArray_h