vtkStreamingTessellator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkStreamingTessellator.h
  Language:  C++
 
  Copyright 2003 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  license for use of this work by or on behalf of the
  U.S. Government. Redistribution and use in source and binary forms, with
  or without modification, are permitted provided that this Notice and any
  statement of authorship are reproduced on all copies.
 
=========================================================================*/
#ifndef vtkStreamingTessellator_h
#define vtkStreamingTessellator_h
 
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkObject.h"
 
#undef PARAVIEW_DEBUG_TESSELLATOR
 
class vtkEdgeSubdivisionCriterion;
 
class VTKFILTERSCORE_EXPORT vtkStreamingTessellator : public vtkObject
{
  public:
    vtkTypeMacro(vtkStreamingTessellator,vtkObject);
    static vtkStreamingTessellator* New();
    virtual void PrintSelf( ostream& os, vtkIndent indent );
 
    //BTX
    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};
 
 
    virtual void SetTetrahedronCallback( TetrahedronProcessorFunction );
    virtual TetrahedronProcessorFunction GetTetrahedronCallback() const;
 
 
    virtual void SetTriangleCallback( TriangleProcessorFunction );
    virtual TriangleProcessorFunction GetTriangleCallback() const;
 
 
    virtual void SetEdgeCallback( EdgeProcessorFunction );
    virtual EdgeProcessorFunction GetEdgeCallback() const;
 
 
    virtual void SetVertexCallback( VertexProcessorFunction );
    virtual VertexProcessorFunction GetVertexCallback() const;
    //ETX
 
 
    virtual void SetPrivateData( void* Private );
    virtual void* GetPrivateData() const;
 
    // can't wrap const private data because python wrapper will try to cast it to void*, not const void*
    //BTX
 
    virtual void SetConstPrivateData( const void* ConstPrivate );
    virtual const void* GetConstPrivateData() const;
    //ETX
 
 
    virtual void SetSubdivisionAlgorithm( vtkEdgeSubdivisionCriterion* );
    virtual vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm() ;
    //BTX
    virtual const vtkEdgeSubdivisionCriterion* GetSubdivisionAlgorithm() const;
    //ETX
 
 
    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 AdaptivelySample3Facet( double* v1, double* v2, double* v3, double* v4 ) const ;
    void AdaptivelySample2Facet( double* v1, double* v2, double* v3 ) const ;
    void AdaptivelySample1Facet( double* v1, double* v2 ) const ;
    void AdaptivelySample0Facet( double* v1 ) 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:
    //BTX
    static int EdgeCodesToCaseCodesPlusPermutation[64][2];
    static vtkIdType PermutationsFromIndex[24][14];
    static vtkIdType TetrahedralDecompositions[];
    //ETX
 
    void* PrivateData;
    const void* ConstPrivateData;
    vtkEdgeSubdivisionCriterion* Algorithm;
    //BTX
    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
    //ETX
 
    int PointDimension[4];
 
    int EmbeddingDimension[4];
 
    int MaximumNumberOfSubdivisions;
 
    vtkStreamingTessellator();
    ~vtkStreamingTessellator();
 
    void AdaptivelySample3Facet( double* v1, double* v2, double* v3, double* v4, int maxDepth ) const ;
    void AdaptivelySample2Facet( double* v1, double* v2, double* v3, int maxDepth, int move=7 ) const ;
    void AdaptivelySample1Facet( double* v1, double* v2, int maxDepth ) const ;
 
    int BestTets( int*, double**, int, int ) const;
 
  private:
    vtkStreamingTessellator( const vtkStreamingTessellator& ); // Not implemented.
    void operator = ( const vtkStreamingTessellator& ); // Not implemented.
};
 
//BTX
 
inline void vtkStreamingTessellator::AdaptivelySample3Facet( double* v1, double* v2, double* v3, double* v4 ) const
{ this->AdaptivelySample3Facet( v1, v2, v3, v4, this->MaximumNumberOfSubdivisions ); }
inline void vtkStreamingTessellator::AdaptivelySample2Facet( double* v1, double* v2, double* v3 ) const
{ this->AdaptivelySample2Facet( v1, v2, v3, this->MaximumNumberOfSubdivisions ); }
inline void vtkStreamingTessellator::AdaptivelySample1Facet( double* v1, double* v2 ) const
{ this->AdaptivelySample1Facet( v1, v2, 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;}
 
//ETX
 
#endif // vtkStreamingTessellator_h