vtkUnstructuredGridSides.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 vtkUnstructuredGridSides_h
#define vtkUnstructuredGridSides_h
 
#include "vtkCellGridSidesQuery.h"    // For SideFlags and SummaryStrategy
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataSetAttributes.h"     // For HIDDENCELL and REFINEDCELL
#include "vtkKeys.h"                  // For DenseKeys and ReducedKeys
#include "vtkObject.h"
#include "vtkType.h" // For vtkIdType, VTK_ID_MAX and VTK_DOUBLE_MAX
 
#include <cstdint> // For std::uint8_t
#include <memory>  // For std::unique_ptr
 
VTK_ABI_NAMESPACE_BEGIN
class vtkGenericCell;
class vtkIdList;
class vtkUnstructuredGrid;
 
template <typename TId = vtkIdType, typename TSideId = vtkTypeInt8>
class VTKCOMMONDATAMODEL_EXPORT vtkUnstructuredGridSides : public vtkObject
{
public:
  using SelfType = vtkUnstructuredGridSides<TId, TSideId>;
  static SelfType* New();
  vtkTemplateTypeMacro(SelfType, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  using SideFlags = vtkCellGridSidesQuery::SideFlags;

  using SummaryStrategy = vtkCellGridSidesQuery::SummaryStrategy;


  virtual void SetDataSet(vtkUnstructuredGrid* dataSet);
  vtkGetObjectMacro(DataSet, vtkUnstructuredGrid);


  vtkSetMacro(PreserveRenderableInputs, bool);
  vtkGetMacro(PreserveRenderableInputs, bool);
  vtkBooleanMacro(PreserveRenderableInputs, bool);


  vtkSetMacro(OmitSidesForRenderableInputs, bool);
  vtkGetMacro(OmitSidesForRenderableInputs, bool);
  vtkBooleanMacro(OmitSidesForRenderableInputs, bool);


  vtkSetClampMacro(OutputDimensionControl, int, 0, SideFlags::AllSides);
  vtkGetMacro(OutputDimensionControl, int);


  vtkSetMacro(Strategy, SummaryStrategy);
  void SetStrategyToWinding() { this->SetStrategy(SummaryStrategy::Winding); }
  void SetStrategyToAnyOccurrence() { this->SetStrategy(SummaryStrategy::AnyOccurrence); }
  void SetStrategyToBoundary() { this->SetStrategy(SummaryStrategy::Boundary); }
  virtual void SetStrategy(int strategy)
  {
    this->SetStrategy(static_cast<SummaryStrategy>(strategy));
  }
  vtkGetMacro(Strategy, SummaryStrategy);


  vtkSetMacro(PointClipping, bool);
  vtkGetMacro(PointClipping, bool);
  vtkBooleanMacro(PointClipping, bool);


  vtkSetMacro(CellClipping, bool);
  vtkGetMacro(CellClipping, bool);
  vtkBooleanMacro(CellClipping, bool);


  vtkSetMacro(ExtentClipping, bool);
  vtkGetMacro(ExtentClipping, bool);
  vtkBooleanMacro(ExtentClipping, bool);


  vtkSetClampMacro(PointMinimum, vtkIdType, 0, VTK_ID_MAX);
  vtkGetMacro(PointMinimum, vtkIdType);
  vtkSetClampMacro(PointMaximum, vtkIdType, 0, VTK_ID_MAX);
  vtkGetMacro(PointMaximum, vtkIdType);


  vtkSetClampMacro(CellMinimum, vtkIdType, 0, VTK_ID_MAX);
  vtkGetMacro(CellMinimum, vtkIdType);
  vtkSetClampMacro(CellMaximum, vtkIdType, 0, VTK_ID_MAX);
  vtkGetMacro(CellMaximum, vtkIdType);


  vtkSetVector6Macro(Extent, double);
  vtkGetVector6Macro(Extent, double);


  vtkSetMacro(RemoveGhostInterfaces, bool);
  vtkGetMacro(RemoveGhostInterfaces, bool);
  vtkBooleanMacro(RemoveGhostInterfaces, bool);


  vtkSetMacro(MaskedGhostTypes, unsigned char);
  vtkGetMacro(MaskedGhostTypes, unsigned char);


  vtkSetMacro(MatchSidePoints, bool);
  vtkGetMacro(MatchSidePoints, bool);
  vtkBooleanMacro(MatchSidePoints, bool);

  enum class BuildMode : std::uint8_t
  {
    None,      
    Scattered, 
    Reduced,   
    Grouped    
  };

  void BuildScatteredSides();

  void BuildReducedSides();

  void BuildGroupedSides();

  BuildMode GetBuildMode() const { return this->Mode; }

  void Reset();

  vtkGetMacro(BuildTime, vtkMTimeType);

  bool UsesGarbageCollector() const override { return true; }
 
  //------------------------------------------------------------------------------
  // The sides, after any build: by key, and by their index k in their key. BuildScatteredSides()
  // and BuildReducedSides() have no getters of their own.
  //------------------------------------------------------------------------------

  vtkIdType GetNumberOfSides() const;

  TId GetNumberOfKeys() const;

  vtkIdType GetNumberOfSidesOfKey(TId keyId) const;

  vtkIdType GetSideOffsetOfKey(TId keyId) const;

  const TId* GetCellIdsOfKey(TId keyId) const;

  const TSideId* GetSideIdsOfKey(TId keyId) const;


  TId GetCellIdOfSide(TId keyId, vtkIdType k) const;
  TSideId GetSideIdOfSide(TId keyId, vtkIdType k) const;
  int GetDimensionOfSide(TId keyId, vtkIdType k) const;

  struct SideInformation
  {
    vtkIdType CellId;       // the cell of the side
    unsigned char CellType; // the cell type of its cell
    int SideId;             // its local index in its cell, -1 for a preserved cell
    int SideType;           // its cell type, e.g., VTK_QUADRATIC_QUAD for a face of a quadratic hex
    int SideDimension;      // its dimension, the one of its cell for a preserved cell
    int SideSize;           // its number of points
  };

  SideInformation GetSideInformation(TId keyId, vtkIdType k, vtkGenericCell* tempCell) const;

  void GetSidePoints(TId keyId, vtkIdType k, vtkIdList* sidePtIds, unsigned char& cellType,
    vtkIdList* tempCellPointIds, vtkGenericCell* tempCell) const;
 
  //------------------------------------------------------------------------------
  // The groups of equal sides, after BuildGroupedSides() only, none otherwise.
  //------------------------------------------------------------------------------


  vtkIdType GetNumberOfGroups() const;
  vtkIdType GetGroupOffsetOfKey(TId keyId) const;


  vtkIdType GetNumberOfSidesOfGroup(vtkIdType group) const;
  vtkIdType GetSideOffsetOfGroup(vtkIdType group) const;


  const TId* GetCellIdsOfGroup(vtkIdType group) const;
  const TSideId* GetSideIdsOfGroup(vtkIdType group) const;

  int GetDimensionOfGroup(vtkIdType group) const;
 
protected:
  vtkUnstructuredGridSides();
  ~vtkUnstructuredGridSides() override;
 
  vtkTimeStamp BuildTime; // time at which the sides were built
 
  void ReportReferences(vtkGarbageCollector*) override;
 
private:
  vtkUnstructuredGridSides(const vtkUnstructuredGridSides&) = delete;
  void operator=(const vtkUnstructuredGridSides&) = delete;
 
  // Find and scatter the sides, see BuildScatteredSides(), and reduce or group them as given by
  // the mode.
  void BuildSides(BuildMode mode);
 
  // Where the sides of a key start in their arrays, which keep the kept sides of a key at the
  // front of its sides, with gaps between the keys, unlike GetSideOffsetOfKey(): the last key, of
  // the preserved cells, starts after all the found sides.
  vtkIdType GetStorageOffsetOfKey(TId keyId) const;
 
  // The steps of BuildSides(), defined in the .cxx file, nested so that they read the settings
  // directly.
  template <class OffsetsT, class ConnectivityT>
  struct InputCells;
  template <class InputCellsT>
  struct SideMapper;
  template <class InputCellsT, bool Faces>
  struct MatchingFunctor;
  struct PreservedCells;
  struct BuildSidesWorker;
 
  // The settings.
  vtkUnstructuredGrid* DataSet = nullptr;
  bool PreserveRenderableInputs = false;
  bool OmitSidesForRenderableInputs = false;
  int OutputDimensionControl = SideFlags::NextLowestDimension;
  SummaryStrategy Strategy = SummaryStrategy::Boundary;
  bool PointClipping = false;
  bool CellClipping = false;
  bool ExtentClipping = false;
  vtkIdType PointMinimum = 0;
  vtkIdType PointMaximum = VTK_ID_MAX;
  vtkIdType CellMinimum = 0;
  vtkIdType CellMaximum = VTK_ID_MAX;
  double Extent[6] = { -VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX, VTK_DOUBLE_MAX,
    -VTK_DOUBLE_MAX, VTK_DOUBLE_MAX };
  bool RemoveGhostInterfaces = true;
  unsigned char MaskedGhostTypes =
    vtkDataSetAttributes::HIDDENCELL | vtkDataSetAttributes::REFINEDCELL;
  bool MatchSidePoints = true;
 
  // The sides, scattered by their key, their smallest point id (ScatteredKeys), the number of kept
  // sides at the front of the sides of every key once reduced (ReducedKeys), and the groups of
  // equal sides and the number of groups of every key once grouped (Groups): their cell, local
  // index and dimension, unless they all have the dimension SideDimension. The cell and local index
  // of the preserved cells are after them. BuiltKeys, the keys of the built sides, which the
  // getters read, is ScatteredKeys, or ReducedKeys once reduced.
  using KeysType = vtk::keys::DenseKeys<TId>;
  KeysType ScatteredKeys;
  vtk::keys::ReducedKeys<KeysType> ReducedKeys;
  vtk::keys::Grouping<KeysType> Groups;
  const KeysType* BuiltKeys = &this->ScatteredKeys;
  BuildMode Mode = BuildMode::None;
  std::unique_ptr<TId[]> CellIds;
  std::unique_ptr<TSideId[]> SideIds;
  std::unique_ptr<std::uint8_t[]> Dimensions;
  std::uint8_t SideDimension = 0;
 
  // The number of preserved cells, in the last key, in the order of their ids: they are not
  // scattered, since they are not matched.
  vtkIdType NumberOfPreservedCells = 0;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkUnstructuredGridSides_h
 
#if defined(VTK_UNSTRUCTURED_GRID_SIDES_INSTANTIATING)
 
#define VTK_UNSTRUCTURED_GRID_SIDES_INSTANTIATE(TId, TSideId)                                      \
  VTK_ABI_NAMESPACE_BEGIN                                                                          \
  template class VTKCOMMONDATAMODEL_EXPORT vtkUnstructuredGridSides<TId, TSideId>;                 \
  VTK_ABI_NAMESPACE_END
 
// MinGW GCC does not reliably export the inline member functions of vtkTemplateTypeMacro with
// extern template, see vtkAOSDataArrayTemplate.h.
#elif defined(VTK_USE_EXTERN_TEMPLATE) && !defined(__MINGW32__)
 
#ifndef VTK_UNSTRUCTURED_GRID_SIDES_TEMPLATE_EXTERN
#define VTK_UNSTRUCTURED_GRID_SIDES_TEMPLATE_EXTERN
#ifdef _MSC_VER
#pragma warning(push)
// The following is needed when vtkUnstructuredGridSides is declared dllexport and is used from
// another class in vtkCommonDataModel.
#pragma warning(disable : 4910) // extern and dllexport incompatible
#endif
VTK_ABI_NAMESPACE_BEGIN
extern template class VTKCOMMONDATAMODEL_EXPORT vtkUnstructuredGridSides<vtkTypeInt32, vtkTypeInt8>;
extern template class VTKCOMMONDATAMODEL_EXPORT
  vtkUnstructuredGridSides<vtkTypeInt32, vtkTypeInt32>;
extern template class VTKCOMMONDATAMODEL_EXPORT vtkUnstructuredGridSides<vtkTypeInt64, vtkTypeInt8>;
extern template class VTKCOMMONDATAMODEL_EXPORT
  vtkUnstructuredGridSides<vtkTypeInt64, vtkTypeInt32>;
VTK_ABI_NAMESPACE_END
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif // VTK_UNSTRUCTURED_GRID_SIDES_TEMPLATE_EXTERN
 
#endif
// VTK-HeaderTest-Exclude: vtkUnstructuredGridSides.h