vtkResolveHangingNodes.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 vtkResolveHangingNodes_h
#define vtkResolveHangingNodes_h
 
#include "vtkBoundingBox.h" // For BoundaryBins
#include "vtkDataObjectAlgorithm.h"
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkSmartPointer.h"      // For vtkSmartPointer
#include "vtkWrappingHints.h"     // For VTK_MARSHALAUTO
 
#include <bitset>      // For BoundaryBins
#include <map>         // For MergeReceivedPoints
#include <string>      // For OriginalCellIdsName
#include <type_traits> // For BoundaryBins
#include <vector>      // For std::vector
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataSet;
class vtkPartitionedDataSet;
class vtkPointSet;
class vtkPolyData;
 
class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO vtkResolveHangingNodes : public vtkDataObjectAlgorithm
{
public:
  static vtkResolveHangingNodes* New();
  vtkTypeMacro(vtkResolveHangingNodes, vtkDataObjectAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetClampMacro(Tolerance, double, 0.0, 0.1);
  vtkGetMacro(Tolerance, double);

  vtkGetMacro(NumberOfLevels, int);


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


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


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


  vtkSetStdStringFromCharMacro(OriginalCellIdsName);
  vtkGetCharFromStdStringMacro(OriginalCellIdsName);
 
protected:
  vtkResolveHangingNodes() = default;
  ~vtkResolveHangingNodes() override = default;
 
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestDataObject(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  virtual bool UseRemotePoints() { return false; }

  virtual void GetGlobalMeasureRange(double vtkNotUsed(range)[2], int& vtkNotUsed(dimension)) {}

  virtual std::vector<vtkSmartPointer<vtkPolyData>> GetRemotePoints(
    const std::vector<vtkPolyData*>& boundaries, const std::vector<int>& partitionedDataSetIds);

  virtual void GetCentroidGlobalIdsOffset(vtkIdType& vtkNotUsed(maxGlobalId),
    vtkIdType numberOfCentroidPoints, vtkIdType& offset, vtkIdType& totalNumberOfCentroidPoints)
  {
    offset = 0;
    totalNumberOfCentroidPoints = numberOfCentroidPoints;
  }
 
#ifndef __VTK_WRAP__
  static vtkBoundingBox GetBoundaryBounds(vtkPolyData* boundary, double tolerance);

  struct VTKFILTERSCORE_EXPORT BoundaryBins
  {
    // Target number of bins (see vtkBoundingBox::ComputeDivisions).
    static constexpr vtkIdType TargetNumberOfBins = 32 * 32 * 32;
 
    // Bounds of the bins, which may be larger than the bounds the bins were initialized with along
    // an axis where they are flat (see vtkBoundingBox::ComputeDivisions).
    vtkBoundingBox Bounds;
    int Divisions[3] = { 1, 1, 1 };
    // One bit per bin, by bin index. ComputeDivisions never makes more bins than the target.
    using OccupiedBitset = std::bitset<TargetNumberOfBins>;
    // diy sends it as raw bytes.
    static_assert(
      std::is_trivially_copyable_v<OccupiedBitset>, "the bitset must be trivially copyable");
    OccupiedBitset Occupied;
 
    // Set the bounds and the divisions, with bins as close to cubes as possible, all unoccupied.
    // The result only depends on `bounds`, so a neighbor initialized with the same bounds has the
    // same bins, and only the occupied bits need to be exchanged.
    void Initialize(const vtkBoundingBox& bounds);
 
    vtkIdType GetNumberOfBins() const;
 
    // The bin indices ijk of the point `x`, clamped to the bins.
    void GetBinIndices(const double* x, int ijk[3]) const;
 
    vtkIdType GetBinIndex(const int ijk[3]) const;
 
    void SetBinOccupied(vtkIdType binId);
 
    vtkIdType GetBinIndex(const double* x) const;
 
    bool IsBinOccupied(vtkIdType binId) const;
 
    // Whether `x` is within the bounds, in an occupied bin.
    bool IsInOccupiedBin(const double* x) const;
  };

  static void BinBoundaryElements(BoundaryBins& bins, vtkPolyData* boundary, double tolerance);

  static vtkSmartPointer<vtkPolyData> ExtractPointsInBins(
    vtkPolyData* source, const BoundaryBins& bins);
#endif

  vtkSmartPointer<vtkPolyData> MergeReceivedPoints(
    const std::map<int, vtkSmartPointer<vtkPolyData>>& received, vtkPolyData* reference) const;
 
  double Tolerance = 1e-6;
  int NumberOfLevels = 0;
  bool Decompose = true;
  bool ComputeInverseMeasure = false;
  bool PassThroughCellIds = false;
  std::string OriginalCellIdsName = "vtkOriginalResolvedCellIds";
 
private:
  vtkResolveHangingNodes(const vtkResolveHangingNodes&) = delete;
  void operator=(const vtkResolveHangingNodes&) = delete;

  int CheckAndResolvePartitions(std::vector<vtkSmartPointer<vtkDataSet>> inputs,
    std::vector<vtkSmartPointer<vtkPointSet>> outputs,
    const std::vector<int>& partitionedDataSetIds);

  template <int Dim>
  int ResolvePartitions(const std::vector<vtkSmartPointer<vtkDataSet>>& inputs,
    const std::vector<vtkSmartPointer<vtkPointSet>>& outputs,
    const std::vector<int>& partitionedDataSetIds);

  int ResolvePartitionedDataSet(vtkPartitionedDataSet* inputPDS, vtkPartitionedDataSet* outputPDS);
 
  // The largest point global id that the new global ids of the center points follow: the largest
  // one of the whole input, then of the center points numbered so far, so that the
  // vtkPartitionedDataSet of a collection, resolved one after the other, get unique global ids.
  vtkIdType MaxPointGlobalId = -1;
};
 
VTK_ABI_NAMESPACE_END
#endif