vtkOrderedTriangulator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkOrderedTriangulator.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 vtkOrderedTriangulator_h
#define vtkOrderedTriangulator_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
 
class vtkUnstructuredGrid;
class vtkCellArray;
class vtkHeap;
class vtkIdList;
class vtkPoints;
class vtkTetra;
class vtkDataArray;
class vtkDoubleArray;
struct vtkOTMesh;
struct vtkOTTemplates;
class vtkIncrementalPointLocator;
class vtkPointData;
class vtkCellData;
 
// Template ID's must be 32-bits. See .cxx file for more information.
#if VTK_SIZEOF_SHORT == 4
typedef unsigned short TemplateIDType;
#elif VTK_SIZEOF_INT == 4
typedef unsigned int TemplateIDType;
#elif VTK_SIZEOF_LONG == 4
typedef unsigned long TemplateIDType;
#endif
 
class VTKCOMMONDATAMODEL_EXPORT vtkOrderedTriangulator : public vtkObject
{
public:
  vtkTypeMacro(vtkOrderedTriangulator, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkOrderedTriangulator* New();
 
 
  void InitTriangulation(
    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts);
  void InitTriangulation(double bounds[6], int numPts);
 
 
  vtkIdType InsertPoint(vtkIdType id, double x[3], double p[3], int type);
  vtkIdType InsertPoint(vtkIdType id, vtkIdType sortid, double x[3], double p[3], int type);
  vtkIdType InsertPoint(
    vtkIdType id, vtkIdType sortid, vtkIdType sortid2, double x[3], double p[3], int type);
 
 
  void Triangulate();
  void TemplateTriangulate(int cellType, int numPts, int numEdges);
 
  void UpdatePointType(vtkIdType internalId, int type);
 
  double* GetPointPosition(vtkIdType internalId);
 
  double* GetPointLocation(vtkIdType internalId);
 
  vtkIdType GetPointId(vtkIdType internalId);
 
 
  vtkGetMacro(NumberOfPoints, int);
 
 
  vtkSetMacro(UseTemplates, vtkTypeBool);
  vtkGetMacro(UseTemplates, vtkTypeBool);
  vtkBooleanMacro(UseTemplates, vtkTypeBool);
 
 
  vtkSetMacro(PreSorted, vtkTypeBool);
  vtkGetMacro(PreSorted, vtkTypeBool);
  vtkBooleanMacro(PreSorted, vtkTypeBool);
 
 
  vtkSetMacro(UseTwoSortIds, vtkTypeBool);
  vtkGetMacro(UseTwoSortIds, vtkTypeBool);
  vtkBooleanMacro(UseTwoSortIds, vtkTypeBool);
 
  vtkIdType GetTetras(int classification, vtkUnstructuredGrid* ugrid);
 
  vtkIdType AddTetras(int classification, vtkUnstructuredGrid* ugrid);
 
  vtkIdType AddTetras(int classification, vtkCellArray* connectivity);
 
  vtkIdType AddTetras(int classification, vtkIncrementalPointLocator* locator,
    vtkCellArray* outConnectivity, vtkPointData* inPD, vtkPointData* outPD, vtkCellData* inCD,
    vtkIdType cellId, vtkCellData* outCD);
 
  vtkIdType AddTetras(int classification, vtkIdList* ptIds, vtkPoints* pts);
 
  vtkIdType AddTriangles(vtkCellArray* connectivity);
 
  vtkIdType AddTriangles(vtkIdType id, vtkCellArray* connectivity);
 
  void InitTetraTraversal();
 
  int GetNextTetra(
    int classification, vtkTetra* tet, vtkDataArray* cellScalars, vtkDoubleArray* tetScalars);
 
protected:
  vtkOrderedTriangulator();
  ~vtkOrderedTriangulator() override;
 
private:
  void Initialize();
 
  vtkOTMesh* Mesh;
  int NumberOfPoints;        // number of points inserted
  int MaximumNumberOfPoints; // maximum possible number of points to be inserted
  double Bounds[6];
  vtkTypeBool PreSorted;
  vtkTypeBool UseTwoSortIds;
  vtkHeap* Heap;
 
  vtkTypeBool UseTemplates;
  int CellType;
  int NumberOfCellPoints;
  int NumberOfCellEdges;
  vtkHeap* TemplateHeap;
  vtkOTTemplates* Templates;
  int TemplateTriangulation();
  void AddTemplate();
  TemplateIDType ComputeTemplateIndex();
 
private:
  vtkOrderedTriangulator(const vtkOrderedTriangulator&) = delete;
  void operator=(const vtkOrderedTriangulator&) = delete;
};
 
#endif