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) override;
 
  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);
 
  vtkTypeBool 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;
 
  VTK_NEWINSTANCE
  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(
    const 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(const 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 tessellation 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 const vtkIdType* GetFaceArray(vtkIdType faceId) = 0;
 
  virtual int GetNumberOfVerticesOnFace(int faceId) = 0;
 
  virtual const vtkIdType* GetEdgeArray(vtkIdType edgeId) = 0;
 
protected:
  vtkGenericAdaptorCell();
  ~vtkGenericAdaptorCell() override;
 
  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&) = delete;
  void operator=(const vtkGenericAdaptorCell&) = delete;
};
 
#endif