vtkBridgeCell.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkBridgeCell.h,v $

  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 __vtkBridgeCell_h
#define __vtkBridgeCell_h

#include "vtkBridgeExport.h"
#include "vtkGenericAdaptorCell.h"

class vtkCell;
class vtkBridgeDataSet;
class vtkBridgeCellIterator;

class VTK_BRIDGE_EXPORT vtkBridgeCell : public vtkGenericAdaptorCell
{
public:
  static vtkBridgeCell *New();
  vtkTypeRevisionMacro(vtkBridgeCell,vtkGenericAdaptorCell);
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual vtkIdType GetId();

  virtual int IsInDataSet();
  
  virtual int GetType();

  virtual int GetDimension();

  virtual int GetGeometryOrder();
  
  int IsGeometryLinear();
  
  virtual int GetAttributeOrder(vtkGenericAttribute *a);
  
  int IsAttributeLinear(vtkGenericAttribute *a);
  
  virtual int IsPrimary();

  virtual int GetNumberOfPoints();

  virtual int GetNumberOfBoundaries(int dim=-1);

  virtual int GetNumberOfDOFNodes();
  
  virtual void GetPointIterator(vtkGenericPointIterator *it);
  
  virtual vtkGenericCellIterator *NewCellIterator();
 

  virtual void GetBoundaryIterator(vtkGenericCellIterator *boundaries,
                                   int dim=-1);
  

  virtual int CountNeighbors(vtkGenericAdaptorCell *boundary);
  void CountEdgeNeighbors( int* sharing );


  virtual void GetNeighbors(vtkGenericAdaptorCell *boundary,
                            vtkGenericCellIterator *neighbors);


  virtual int FindClosestBoundary(int subId,
                                  double pcoords[3],
                                  vtkGenericCellIterator* &boundary);


  virtual int EvaluatePosition(double x[3],
                               double *closestPoint, 
                               int &subId,
                               double pcoords[3], 
                               double &dist2);
  

  virtual void EvaluateLocation(int subId,
                                double pcoords[3],
                                double x[3]);
  

  virtual void InterpolateTuple(vtkGenericAttribute *a, double pcoords[3],
                                double *val);


  virtual void InterpolateTuple(vtkGenericAttributeCollection *c, double pcoords[3],
                                double *val);
#if 0
  // Description:
  // Generate a contour (contouring primitives) for each `values' or with
  // respect to an implicit function `f'. Contouring
  // is performed on the scalar attribute (`attributes->GetActiveAttribute()',
  // `attributes->GetActiveComponent()').
  // Contouring interpolates the
  // `attributes->GetNumberOfattributesToInterpolate()' attributes
  // `attributes->GetAttributesToInterpolate()'.
  // `locator', `verts', `lines', `polys', `outPd' and `outCd' are cumulative
  // data arrays over cell iterations: they store the result of each call
  // to Contour():
  // - `locator' is points list that merges points as they are inserted (i.e.,
  // prevents duplicates).
  // - `verts' is an array of generated vertices
  // - `lines' is an array of generated lines
  // - `polys' is an array of generated polygons
  // - `outPd' is an array of interpolated point data along the edge (if
  // not-NULL)
  // - `outCd' is an array of copied cell data of the current cell (if 
  // not-NULL)
  // Note: the CopyAllocate() method must be invoked on both the output cell
  // and point data.
  //
  // NOTE: `vtkGenericAttributeCollection *attributes' will be replaced by a
  //       `vtkInformation'.
  //
  // \pre values_exist: (values!=0 && f==0) || (values==0 && f!=0)
  // \pre attributes_exist: attributes!=0
  // \pre locator_exists: locator!=0
  // \pre verts_exist: verts!=0
  // \pre lines_exist: lines!=0
  // \pre polys_exist: polys!=0
  virtual void Contour(vtkContourValues *values,
                       vtkImplicitFunction *f,
                       vtkGenericAttributeCollection *attributes,
                       vtkPointLocator *locator,
                       vtkCellArray *verts,
                       vtkCellArray *lines,
                       vtkCellArray *polys,
                       vtkPointData *outPd,
                       vtkCellData *outCd);
#endif
#if 0


  virtual void Clip(double value,
                    vtkImplicitFunction *f,
                    vtkGenericAttributeCollection *attributes,
                    vtkGenericCellTessellator *tess,
                    int insideOut,
                    vtkPointLocator *locator,
                    vtkCellArray *connectivity,
                    vtkPointData *outPd,
                    vtkCellData *outCd);
#endif


  virtual int IntersectWithLine(double p1[3],
                                double p2[3], 
                                double tol,
                                double &t,
                                double x[3], 
                                double pcoords[3],
                                int &subId);


  virtual void Derivatives(int subId,
                           double pcoords[3],
                           vtkGenericAttribute *attribute,
                           double *derivs);

  virtual void GetBounds(double bounds[6]);

  virtual double *GetBounds();

  virtual double GetLength2();

  virtual int GetParametricCenter(double pcoords[3]);

  virtual double GetParametricDistance(double pcoords[3]);


  virtual double *GetParametricCoords();
#if 0
  // Description:
  // Tessellate the cell if it is not linear or if at least one attribute of
  // `attributes' is not linear. The output are linear cells of the same
  // dimension than than cell. If the cell is linear and all attributes are
  // linear, the output is just a copy of the current cell.
  // `points', `cellArray', `pd' and `cd' are cumulative output data arrays
  // over cell iterations: they store the result of each call to Tessellate().
  // \pre attributes_exist: attributes!=0
  // \pre points_exist: points!=0
  // \pre cellArray_exists: cellArray!=0
  // \pre pd_exist: pd!=0
  // \pre cd_exists: cd!=0
  virtual void Tessellate(vtkGenericAttributeCollection *attributes, 
                          vtkPoints *points, vtkCellArray* cellArray,  
                          vtkPointData *pd, vtkCellData* cd);
#endif
  // For the internals of the tesselation algorithm (the hash table in particular)
  virtual int IsFaceOnBoundary(vtkIdType faceId);
  virtual int IsOnBoundary();


  virtual void GetPointIds(vtkIdType *id);
#if 0
  virtual void TriangulateFace(vtkGenericAttributeCollection *attributes,
                               vtkGenericCellTessellator *tess,
                               int index, 
                               vtkPoints *pts, vtkCellArray *cellArray, 
                               vtkPointData *pd,
                               vtkCellData *cd );
#endif
  
  int *GetFaceArray(int faceId);
  
  int GetNumberOfVerticesOnFace(int faceId);
  
  int *GetEdgeArray(int edgeId);
  

  void Init(vtkBridgeDataSet *ds,
            vtkIdType cellid);


  void InitWithCell(vtkCell *c,
                    vtkIdType id);
  
  void DeepCopy(vtkBridgeCell *other);
  
protected:
  vtkBridgeCell();
  virtual ~vtkBridgeCell();

  void AllocateWeights();

  void InterpolationFunctions(double pcoords[3]);
  
  friend class vtkBridgeDataSet;
  friend class vtkBridgeAttribute;
  friend class vtkBridgeCellIterator;
  friend class vtkBridgeCellIteratorOnDataSet;
  friend class vtkBridgeCellIteratorOne;
  friend class vtkBridgeCellIteratorOnCellBoundaries;
  friend class vtkBridgePointIteratorOnCell;
  
  vtkCell *Cell;
  vtkBridgeDataSet *DataSet;
  vtkIdType Id; // what does it mean for boundary cells?
  int BoolIsInDataSet; 
  vtkBridgeCellIterator *InternalIterator; // used in Contour
  
  double *Weights; // interpolation functions
  int WeightsCapacity;
  
private:
  vtkBridgeCell(const vtkBridgeCell&);  // Not implemented.
  void operator=(const vtkBridgeCell&);  // Not implemented.
};

#endif

---