vtkTessellatorFilter.h

Go to the documentation of this file.

/*=========================================================================

Program:   Visualization Toolkit
Module:    vtkTessellatorFilter.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 vtkTessellatorFilter_h
#define vtkTessellatorFilter_h

#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkUnstructuredGridAlgorithm.h"

class vtkDataArray;
class vtkDataSet;
class vtkDataSetEdgeSubdivisionCriterion;
class vtkPointLocator;
class vtkPoints;
class vtkStreamingTessellator;
class vtkEdgeSubdivisionCriterion;
class vtkUnstructuredGrid;

class VTKFILTERSGENERAL_EXPORT vtkTessellatorFilter : public vtkUnstructuredGridAlgorithm
{
public:
  vtkTypeMacro(vtkTessellatorFilter,vtkUnstructuredGridAlgorithm);
  void PrintSelf( ostream& os, vtkIndent indent );

  static vtkTessellatorFilter* New();

  virtual void SetTessellator( vtkStreamingTessellator* );
  vtkGetObjectMacro(Tessellator, vtkStreamingTessellator);

  virtual void SetSubdivider( vtkDataSetEdgeSubdivisionCriterion* );
  vtkGetObjectMacro(Subdivider, vtkDataSetEdgeSubdivisionCriterion);

  virtual unsigned long GetMTime();


  vtkSetClampMacro(OutputDimension,int,1,3);
  vtkGetMacro(OutputDimension,int);
  //BTX
  int GetOutputDimension() const;
  //ETX


  virtual void SetMaximumNumberOfSubdivisions( int num_subdiv_in );
  int GetMaximumNumberOfSubdivisions();
  virtual void SetChordError( double ce );
  double GetChordError();


  virtual void ResetFieldCriteria();
  virtual void SetFieldCriterion( int field, double chord );


  vtkGetMacro(MergePoints,int);
  vtkSetMacro(MergePoints,int);
  vtkBooleanMacro(MergePoints,int);

protected:
  vtkTessellatorFilter();
  ~vtkTessellatorFilter();

  virtual int FillInputPortInformation(int port, vtkInformation* info);

  void SetupOutput( vtkDataSet* input, vtkUnstructuredGrid* output );

  void MergeOutputPoints( vtkUnstructuredGrid* input, vtkUnstructuredGrid* output );

  void Teardown();


  virtual int RequestData(vtkInformation* request,
                          vtkInformationVector** inputVector,
                          vtkInformationVector* outputVector);

  //BTX
  vtkStreamingTessellator* Tessellator;
  vtkDataSetEdgeSubdivisionCriterion* Subdivider;
  int OutputDimension;
  int MergePoints;
  vtkPointLocator* Locator;


  vtkUnstructuredGrid* OutputMesh;
  vtkPoints* OutputPoints;
  vtkDataArray** OutputAttributes;
  int* OutputAttributeIndices;

  static void AddAPoint( const double*,
                         vtkEdgeSubdivisionCriterion*,
                         void*,
                         const void* );
  static void AddALine( const double*,
                        const double*,
                        vtkEdgeSubdivisionCriterion*,
                        void*,
                        const void* );
  static void AddATriangle( const double*,
                            const double*,
                            const double*,
                            vtkEdgeSubdivisionCriterion*,
                            void*,
                            const void* );
  static void AddATetrahedron( const double*,
                               const double*,
                               const double*,
                               const double*,
                               vtkEdgeSubdivisionCriterion*,
                               void*,
                               const void* );
  void OutputPoint( const double* );
  void OutputLine( const double*, const double* );
  void OutputTriangle( const double*, const double*, const double* );
  void OutputTetrahedron( const double*,
                          const double*,
                          const double*,
                          const double* );
  //ETX

private:
  vtkTessellatorFilter( const vtkTessellatorFilter& ); // Not implemented.
  void operator = ( const vtkTessellatorFilter& ); // Not implemented.
};

//BTX
inline int vtkTessellatorFilter::GetOutputDimension() const
{
  return this->OutputDimension;
}
//ETX

#endif // vtkTessellatorFilter_h