VTK  9.0.1
vtkStreamingTessellator.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkStreamingTessellator.h
5  Language: C++
6 
7  Copyright 2003 Sandia Corporation.
8  Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
9  license for use of this work by or on behalf of the
10  U.S. Government. Redistribution and use in source and binary forms, with
11  or without modification, are permitted provided that this Notice and any
12  statement of authorship are reproduced on all copies.
13 
14 =========================================================================*/
75 #ifndef vtkStreamingTessellator_h
76 #define vtkStreamingTessellator_h
77 
78 #include "vtkFiltersCoreModule.h" // For export macro
79 #include "vtkObject.h"
80 
81 #undef PARAVIEW_DEBUG_TESSELLATOR
82 
84 
85 class VTKFILTERSCORE_EXPORT vtkStreamingTessellator : public vtkObject
86 {
87 public:
89  static vtkStreamingTessellator* New();
90  void PrintSelf(ostream& os, vtkIndent indent) override;
91 
92  typedef void (*VertexProcessorFunction)(
93  const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
94  typedef void (*EdgeProcessorFunction)(
95  const double*, const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
96  typedef void (*TriangleProcessorFunction)(
97  const double*, const double*, const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
98  typedef void (*TetrahedronProcessorFunction)(const double*, const double*, const double*,
99  const double*, vtkEdgeSubdivisionCriterion*, void*, const void*);
100 
101  enum
102  {
103  MaxFieldSize = 18
104  };
105 
107 
110  virtual void SetTetrahedronCallback(TetrahedronProcessorFunction);
111  virtual TetrahedronProcessorFunction GetTetrahedronCallback() const;
113 
115 
118  virtual void SetTriangleCallback(TriangleProcessorFunction);
119  virtual TriangleProcessorFunction GetTriangleCallback() const;
121 
123 
126  virtual void SetEdgeCallback(EdgeProcessorFunction);
127  virtual EdgeProcessorFunction GetEdgeCallback() const;
129 
131 
134  virtual void SetVertexCallback(VertexProcessorFunction);
135  virtual VertexProcessorFunction GetVertexCallback() const;
137 
139 
142  virtual void SetPrivateData(void* Private);
143  virtual void* GetPrivateData() const;
145 
146  // can't wrap const private data because python wrapper will try to cast it to void*, not const
147  // void*
148 
150 
153  virtual void SetConstPrivateData(const void* ConstPrivate);
154  virtual const void* GetConstPrivateData() const;
156 
158 
165  virtual void SetSubdivisionAlgorithm(vtkEdgeSubdivisionCriterion*);
166  virtual vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm();
168 
169  virtual const vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm() const;
170 
172 
184  virtual void SetEmbeddingDimension(int k, int d);
185  int GetEmbeddingDimension(int k) const;
187 
189 
218  virtual void SetFieldSize(int k, int s);
219  int GetFieldSize(int k) const;
221 
223 
226  virtual void SetMaximumNumberOfSubdivisions(int num_subdiv_in);
227  int GetMaximumNumberOfSubdivisions();
229 
231 
250  void AdaptivelySample3Facet(double* v0, double* v1, double* v2, double* v3) const;
251  void AdaptivelySample2Facet(double* v0, double* v1, double* v2) const;
252  void AdaptivelySample1Facet(double* v0, double* v1) const;
253  void AdaptivelySample0Facet(double* v0) const;
255 
257 
269  void ResetCounts()
270  {
271 #ifdef PARAVIEW_DEBUG_TESSELLATOR
272  for (int i = 0; i < 11; ++i)
273  {
274  this->CaseCounts[i] = 0;
275  for (int j = 0; j < 51; ++j)
276  {
277  this->SubcaseCounts[i][j] = 0;
278  }
279  }
280 #endif // PARAVIEW_DEBUG_TESSELLATOR
281  }
283  {
284 #ifdef PARAVIEW_DEBUG_TESSELLATOR
285  return this->CaseCounts[c];
286 #else
287  (void)c;
288  return 0;
289 #endif // PARAVIEW_DEBUG_TESSELLATOR
290  }
291  vtkIdType GetSubcaseCount(int casenum, int sub)
292  {
293 #ifdef PARAVIEW_DEBUG_TESSELLATOR
294  return this->SubcaseCounts[casenum][sub];
295 #else
296  (void)casenum;
297  (void)sub;
298  return 0;
299 #endif // PARAVIEW_DEBUG_TESSELLATOR
300  }
302 
303 protected:
304  static int EdgeCodesToCaseCodesPlusPermutation[64][2];
305  static vtkIdType PermutationsFromIndex[24][14];
306  static vtkIdType TetrahedralDecompositions[];
307 
308  void* PrivateData;
309  const void* ConstPrivateData;
311 
312  VertexProcessorFunction Callback0;
313  EdgeProcessorFunction Callback1;
314  TriangleProcessorFunction Callback2;
315  TetrahedronProcessorFunction Callback3;
316 #ifdef PARAVIEW_DEBUG_TESSELLATOR
317  mutable vtkIdType CaseCounts[11];
318  mutable vtkIdType SubcaseCounts[11][51];
319 #endif // PARAVIEW_DEBUG_TESSELLATOR
320 
329  int PointDimension[4];
330 
336  int EmbeddingDimension[4];
337 
342 
344  ~vtkStreamingTessellator() override;
345 
346  void AdaptivelySample3Facet(double* v0, double* v1, double* v2, double* v3, int maxDepth) const;
347  void AdaptivelySample2Facet(double* v0, double* v1, double* v2, int maxDepth, int move = 7) const;
348  void AdaptivelySample1Facet(double* v0, double* v1, int maxDepth) const;
349 
350  int BestTets(int*, double**, int, int) const;
351 
352 private:
354  void operator=(const vtkStreamingTessellator&) = delete;
355 };
356 
358  double* v0, double* v1, double* v2, double* v3) const
359 {
360  this->AdaptivelySample3Facet(v0, v1, v2, v3, this->MaximumNumberOfSubdivisions);
361 }
363  double* v0, double* v1, double* v2) const
364 {
365  this->AdaptivelySample2Facet(v0, v1, v2, this->MaximumNumberOfSubdivisions);
366 }
367 inline void vtkStreamingTessellator::AdaptivelySample1Facet(double* v0, double* v1) const
368 {
370 }
371 
373 {
374  if (k <= 0 || k >= 4)
375  return -1;
376  return this->EmbeddingDimension[k];
377 }
378 
380 {
381  if (k <= 0 || k >= 4)
382  return -1;
383  return this->PointDimension[k] - this->EmbeddingDimension[k] - 3;
384 }
385 
387 {
388  return this->MaximumNumberOfSubdivisions;
389 }
390 
391 #endif // vtkStreamingTessellator_h
vtkStreamingTessellator
An algorithm that refines an initial simplicial tessellation using edge subdivision.
Definition: vtkStreamingTessellator.h:85
vtkStreamingTessellator::GetCaseCount
vtkIdType GetCaseCount(int c)
Definition: vtkStreamingTessellator.h:282
vtkStreamingTessellator::GetEmbeddingDimension
int GetEmbeddingDimension(int k) const
Definition: vtkStreamingTessellator.h:372
vtkIdType
int vtkIdType
Definition: vtkType.h:338
vtkObject::New
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:62
vtkStreamingTessellator::Callback1
EdgeProcessorFunction Callback1
Definition: vtkStreamingTessellator.h:313
vtkStreamingTessellator::GetSubcaseCount
vtkIdType GetSubcaseCount(int casenum, int sub)
Definition: vtkStreamingTessellator.h:291
vtkStreamingTessellator::PointDimension
int PointDimension[4]
PointDimension is the length of each double* array associated with each point passed to a subdivision...
Definition: vtkStreamingTessellator.h:329
vtkStreamingTessellator::AdaptivelySample2Facet
void AdaptivelySample2Facet(double *v0, double *v1, double *v2) const
Definition: vtkStreamingTessellator.h:362
vtkStreamingTessellator::AdaptivelySample1Facet
void AdaptivelySample1Facet(double *v0, double *v1) const
Definition: vtkStreamingTessellator.h:367
vtkStreamingTessellator::GetFieldSize
int GetFieldSize(int k) const
Definition: vtkStreamingTessellator.h:379
vtkStreamingTessellator::EmbeddingDimension
int EmbeddingDimension[4]
The parametric dimension of each point passed to the subdivision algorithm.
Definition: vtkStreamingTessellator.h:336
vtkEdgeSubdivisionCriterion
how to decide whether a linear approximation to nonlinear geometry or field should be subdivided
Definition: vtkEdgeSubdivisionCriterion.h:43
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkStreamingTessellator::PrivateData
void * PrivateData
Definition: vtkStreamingTessellator.h:308
vtkStreamingTessellator::AdaptivelySample3Facet
void AdaptivelySample3Facet(double *v0, double *v1, double *v2, double *v3) const
This will adaptively subdivide the tetrahedron (3-facet), triangle (2-facet), or edge (1-facet) until...
Definition: vtkStreamingTessellator.h:357
vtkStreamingTessellator::Callback3
TetrahedronProcessorFunction Callback3
Definition: vtkStreamingTessellator.h:315
vtkObject::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkStreamingTessellator::Algorithm
vtkEdgeSubdivisionCriterion * Algorithm
Definition: vtkStreamingTessellator.h:310
vtkStreamingTessellator::ConstPrivateData
const void * ConstPrivateData
Definition: vtkStreamingTessellator.h:309
vtkObject.h
vtkStreamingTessellator::Callback2
TriangleProcessorFunction Callback2
Definition: vtkStreamingTessellator.h:314
vtkStreamingTessellator::Callback0
VertexProcessorFunction Callback0
Definition: vtkStreamingTessellator.h:312
vtkStreamingTessellator::ResetCounts
void ResetCounts()
Reset/access the histogram of subdivision cases encountered.
Definition: vtkStreamingTessellator.h:269
vtkStreamingTessellator::GetMaximumNumberOfSubdivisions
int GetMaximumNumberOfSubdivisions()
Definition: vtkStreamingTessellator.h:386
vtkStreamingTessellator::MaximumNumberOfSubdivisions
int MaximumNumberOfSubdivisions
The number of subdivisions allowed.
Definition: vtkStreamingTessellator.h:341