vtkGenericAdaptorCell.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGenericAdaptorCell.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkGenericAdaptorCell_h
#define vtkGenericAdaptorCell_h
 
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
 
class vtkLine;
class vtkTetra;
class vtkPoints;
class vtkVertex;
class vtkTriangle;
class vtkCellData;
class vtkPointData;
class vtkCellArray;
class vtkDoubleArray;
class vtkGenericCellIterator;
class vtkIncrementalPointLocator;
class vtkContourValues;
class vtkImplicitFunction;
class vtkGenericCellTessellator;
class vtkGenericAttributeCollection;
class vtkGenericAttribute;
class vtkGenericPointIterator;
class vtkIdList;
class vtkOrderedTriangulator;
class vtkPolygon;
class vtkUnsignedCharArray;
class vtkQuad;
class vtkHexahedron;
class vtkWedge;
class vtkPyramid;
 
class VTKCOMMONDATAMODEL_EXPORT vtkGenericAdaptorCell : public vtkObject
{
public:
  vtkTypeMacro(vtkGenericAdaptorCell,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual vtkIdType GetId() = 0;
 
  virtual int IsInDataSet()=0;
 
  virtual int GetType()=0;
 
  virtual int GetDimension() = 0;
 
  virtual int GetGeometryOrder()=0;
 
  int IsGeometryLinear();
 
  virtual int GetAttributeOrder(vtkGenericAttribute *a)=0;
 
  virtual int GetHighestOrderAttribute(vtkGenericAttributeCollection *ac);
 
  int IsAttributeLinear(vtkGenericAttribute *a);
 
  virtual int IsPrimary()=0;
 
  virtual int GetNumberOfPoints()=0;
 
  virtual int GetNumberOfBoundaries(int dim=-1)=0;
 
  virtual int GetNumberOfDOFNodes()=0;
 
  virtual void GetPointIterator(vtkGenericPointIterator *it)=0;
 
  virtual vtkGenericCellIterator *NewCellIterator()=0;
 
 
  virtual void GetBoundaryIterator(vtkGenericCellIterator *boundaries,
                                   int dim=-1)=0;
 
 
  virtual int CountNeighbors(vtkGenericAdaptorCell *boundary)=0;
  virtual void CountEdgeNeighbors( int* sharing ) = 0;
 
 
  virtual void GetNeighbors(vtkGenericAdaptorCell *boundary,
                            vtkGenericCellIterator *neighbors)=0;
 
 
  virtual int FindClosestBoundary(int subId,
                                  double pcoords[3],
                                  vtkGenericCellIterator* &boundary)=0;
 
 
  virtual int EvaluatePosition(double x[3],
                               double *closestPoint,
                               int &subId,
                               double pcoords[3],
                               double &dist2)=0;
 
 
  virtual void EvaluateLocation(int subId,
                                double pcoords[3],
                                double x[3])=0;
 
 
  virtual void InterpolateTuple(vtkGenericAttribute *a, double pcoords[3],
                                double *val) = 0;
 
 
  virtual void InterpolateTuple(vtkGenericAttributeCollection *c,
                                double pcoords[3],
                                double *val) = 0;
 
 
  virtual void Contour(vtkContourValues *values,
                       vtkImplicitFunction *f,
                       vtkGenericAttributeCollection *attributes,
                       vtkGenericCellTessellator *tess,
                       vtkIncrementalPointLocator *locator,
                       vtkCellArray *verts,
                       vtkCellArray *lines,
                       vtkCellArray *polys,
                       vtkPointData *outPd,
                       vtkCellData *outCd,
                       vtkPointData *internalPd,
                       vtkPointData *secondaryPd,
                       vtkCellData *secondaryCd);
 
 
  virtual void Clip(double value,
                    vtkImplicitFunction *f,
                    vtkGenericAttributeCollection *attributes,
                    vtkGenericCellTessellator *tess,
                    int insideOut,
                    vtkIncrementalPointLocator *locator,
                    vtkCellArray *connectivity,
                    vtkPointData *outPd,
                    vtkCellData *outCd,
                    vtkPointData *internalPd,
                    vtkPointData *secondaryPd,
                    vtkCellData *secondaryCd);
 
 
  virtual int IntersectWithLine(double p1[3],
                                double p2[3],
                                double tol,
                                double &t,
                                double x[3],
                                double pcoords[3],
                                int &subId)=0;
 
 
  virtual void Derivatives(int subId,
                           double pcoords[3],
                           vtkGenericAttribute *attribute,
                           double *derivs)=0;
 
  virtual void GetBounds(double bounds[6])=0;
 
  virtual double *GetBounds();
 
  virtual double GetLength2();
 
  virtual int GetParametricCenter(double pcoords[3])=0;
 
  virtual double GetParametricDistance(double pcoords[3])=0;
 
  virtual double *GetParametricCoords()=0;
 
 
  virtual void Tessellate(vtkGenericAttributeCollection *attributes,
                          vtkGenericCellTessellator *tess,
                          vtkPoints *points,
                          vtkIncrementalPointLocator *locator,
                          vtkCellArray* cellArray,
                          vtkPointData *internalPd,
                          vtkPointData *pd, vtkCellData* cd,
                          vtkUnsignedCharArray *types);
 
  // The following methods are for the internals of the tesselation algorithm
  // (the hash table in particular)
 
  virtual int IsFaceOnBoundary(vtkIdType faceId) = 0;
 
  virtual int IsOnBoundary() = 0;
 
  virtual void GetPointIds(vtkIdType *id) = 0;
 
 
  virtual void TriangulateFace(vtkGenericAttributeCollection *attributes,
                               vtkGenericCellTessellator *tess, int index,
                               vtkPoints *points,
                               vtkIncrementalPointLocator *locator,
                               vtkCellArray *cellArray,
                               vtkPointData *internalPd,
                               vtkPointData *pd, vtkCellData *cd );
 
  virtual int *GetFaceArray(int faceId)=0;
 
  virtual int GetNumberOfVerticesOnFace(int faceId)=0;
 
  virtual int *GetEdgeArray(int edgeId)=0;
 
protected:
  vtkGenericAdaptorCell();
  virtual ~vtkGenericAdaptorCell();
 
  void Reset();
 
  void AllocateTuples(int size);
 
  //Internal tetra used for the contouring/clipping algorithm
  vtkTetra       *Tetra;
  vtkTriangle    *Triangle;
  vtkLine        *Line;
  vtkVertex      *Vertex; //is it used ?
  vtkQuad *Quad;
  vtkHexahedron *Hexa;
  vtkWedge *Wedge;
  vtkPyramid *Pyramid;
 
  // Internal locator when tessellating on a cell basis, this is different
  // from the main locator used in contour/clip filter, this locator is used for
  // points for
  // Be careful the use of a vtkLocator in conjunction with the table fast
  // tessellator is very sensitive, we need to keep all the points we used
  vtkDoubleArray  *InternalPoints;
  vtkCellArray    *InternalCellArray;
  vtkDoubleArray  *InternalScalars;
  vtkDoubleArray  *PointDataScalars;
 
  vtkIdList        *InternalIds; // used by Tessellate() and TriangulateFace()
 
  //Attributes to mimic the vtk cell look and feel, internal use only
  vtkDoubleArray  *Scalars;
  vtkPointData    *PointData;
  vtkCellData     *CellData;
 
  // Scalar buffer to store the attributes values at some location
  // There are variable members to reduce memory allocations.
  double *Tuples;
  int TuplesCapacity;
 
  // Cached Bounds.
  double Bounds[6];
 
private:
  vtkGenericAdaptorCell(const vtkGenericAdaptorCell&);  // Not implemented.
  void operator=(const vtkGenericAdaptorCell&);  // Not implemented.
};
 
#endif