vtkStreamingTessellator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2003 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
#ifndef vtkStreamingTessellator_h
#define vtkStreamingTessellator_h
 
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
#undef PARAVIEW_DEBUG_TESSELLATOR
 
VTK_ABI_NAMESPACE_BEGIN
class vtkEdgeSubdivisionCriterion;
 
class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO vtkStreamingTessellator : public vtkObject
{
public:
  vtkTypeMacro(vtkStreamingTessellator, vtkObject);
  static vtkStreamingTessellator* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  typedef void (*VertexProcessorFunction)(
    const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
  typedef void (*EdgeProcessorFunction)(
    const double*, const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
  typedef void (*TriangleProcessorFunction)(
    const double*, const double*, const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
  typedef void (*TetrahedronProcessorFunction)(const double*, const double*, const double*,
    const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
 
  enum
  {
    MaxFieldSize = 18
  };
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetTetrahedronCallback(TetrahedronProcessorFunction);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual TetrahedronProcessorFunction GetTetrahedronCallback() const;
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetTriangleCallback(TriangleProcessorFunction);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual TriangleProcessorFunction GetTriangleCallback() const;
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetEdgeCallback(EdgeProcessorFunction);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual EdgeProcessorFunction GetEdgeCallback() const;
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetVertexCallback(VertexProcessorFunction);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual VertexProcessorFunction GetVertexCallback() const;
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetPrivateData(void* Private);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void* GetPrivateData() const;
 
  // can't wrap const private data because python wrapper will try to cast it to void*, not const
  // void*
 
 
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual void SetConstPrivateData(const void* ConstPrivate);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  virtual const void* GetConstPrivateData() const;
 
 
  virtual void SetSubdivisionAlgorithm(vtkEdgeSubdivisionCriterion*);
  virtual vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm();
 
  virtual const vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm() const;
 
 
  virtual void SetEmbeddingDimension(int k, int d);
  int GetEmbeddingDimension(int k) const;
 
 
  virtual void SetFieldSize(int k, int s);
  int GetFieldSize(int k) const;
 
 
  virtual void SetMaximumNumberOfSubdivisions(int num_subdiv_in);
  int GetMaximumNumberOfSubdivisions();
 
 
  void AdaptivelySample3FacetLinear(double* v0, double* v1, double* v2, double* v3) const;
  void AdaptivelySample2FacetLinear(double* v0, double* v1, double* v2) const;
  void AdaptivelySample1FacetLinear(double* v0, double* v1) const;
 
  void AdaptivelySample3Facet(double* v0, double* v1, double* v2, double* v3) const;
  void AdaptivelySample2Facet(double* v0, double* v1, double* v2) const;
  void AdaptivelySample1Facet(double* v0, double* v1) const;
  void AdaptivelySample0Facet(double* v0) const;
 
 
  void ResetCounts()
  {
#ifdef PARAVIEW_DEBUG_TESSELLATOR
    for (int i = 0; i < 11; ++i)
    {
      this->CaseCounts[i] = 0;
      for (int j = 0; j < 51; ++j)
      {
        this->SubcaseCounts[i][j] = 0;
      }
    }
#endif // PARAVIEW_DEBUG_TESSELLATOR
  }
  vtkIdType GetCaseCount(int c)
  {
#ifdef PARAVIEW_DEBUG_TESSELLATOR
    return this->CaseCounts[c];
#else
    (void)c;
    return 0;
#endif // PARAVIEW_DEBUG_TESSELLATOR
  }
  vtkIdType GetSubcaseCount(int casenum, int sub)
  {
#ifdef PARAVIEW_DEBUG_TESSELLATOR
    return this->SubcaseCounts[casenum][sub];
#else
    (void)casenum;
    (void)sub;
    return 0;
#endif // PARAVIEW_DEBUG_TESSELLATOR
  }
 
protected:
  static int EdgeCodesToCaseCodesPlusPermutation[64][2];
  static vtkIdType PermutationsFromIndex[24][14];
  static vtkIdType TetrahedralDecompositions[];
 
  void* PrivateData;
  const void* ConstPrivateData;
  vtkEdgeSubdivisionCriterion* Algorithm;
 
  VertexProcessorFunction Callback0;
  EdgeProcessorFunction Callback1;
  TriangleProcessorFunction Callback2;
  TetrahedronProcessorFunction Callback3;
#ifdef PARAVIEW_DEBUG_TESSELLATOR
  mutable vtkIdType CaseCounts[11];
  mutable vtkIdType SubcaseCounts[11][51];
#endif // PARAVIEW_DEBUG_TESSELLATOR
 
  int PointDimension[4];
 
  int EmbeddingDimension[4];
 
  int MaximumNumberOfSubdivisions;
 
  vtkStreamingTessellator();
  ~vtkStreamingTessellator() override;
 
  void AdaptivelySample3Facet(double* v0, double* v1, double* v2, double* v3, int maxDepth) const;
  void AdaptivelySample2Facet(double* v0, double* v1, double* v2, int maxDepth, int move = 7) const;
  void AdaptivelySample1Facet(double* v0, double* v1, int maxDepth) const;
 
  int BestTets(int*, double**, int, int) const;
 
private:
  vtkStreamingTessellator(const vtkStreamingTessellator&) = delete;
  void operator=(const vtkStreamingTessellator&) = delete;
};
 
inline void vtkStreamingTessellator::AdaptivelySample3Facet(
  double* v0, double* v1, double* v2, double* v3) const
{
  this->AdaptivelySample3Facet(v0, v1, v2, v3, this->MaximumNumberOfSubdivisions);
}
inline void vtkStreamingTessellator::AdaptivelySample2Facet(
  double* v0, double* v1, double* v2) const
{
  this->AdaptivelySample2Facet(v0, v1, v2, this->MaximumNumberOfSubdivisions);
}
inline void vtkStreamingTessellator::AdaptivelySample1Facet(double* v0, double* v1) const
{
  this->AdaptivelySample1Facet(v0, v1, this->MaximumNumberOfSubdivisions);
}
 
inline int vtkStreamingTessellator::GetEmbeddingDimension(int k) const
{
  if (k <= 0 || k >= 4)
    return -1;
  return this->EmbeddingDimension[k];
}
 
inline int vtkStreamingTessellator::GetFieldSize(int k) const
{
  if (k <= 0 || k >= 4)
    return -1;
  return this->PointDimension[k] - this->EmbeddingDimension[k] - 3;
}
 
inline int vtkStreamingTessellator::GetMaximumNumberOfSubdivisions()
{
  return this->MaximumNumberOfSubdivisions;
}
 
VTK_ABI_NAMESPACE_END
#endif // vtkStreamingTessellator_h