You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
190 lines
6.8 KiB
C++
190 lines
6.8 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkEdgeTable.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.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkEdgeTable
|
|
* @brief keep track of edges (edge is pair of integer id's)
|
|
*
|
|
* vtkEdgeTable is a general object for keeping track of lists of edges. An
|
|
* edge is defined by the pair of point id's (p1,p2). Methods are available
|
|
* to insert edges, check if edges exist, and traverse the list of edges.
|
|
* Also, it's possible to associate attribute information with each edge.
|
|
* The attribute information may take the form of vtkIdType id's, void*
|
|
* pointers, or points. To store attributes, make sure that
|
|
* InitEdgeInsertion() is invoked with the storeAttributes flag set properly.
|
|
* If points are inserted, use the methods InitPointInsertion() and
|
|
* InsertUniquePoint().
|
|
*/
|
|
|
|
#ifndef vtkEdgeTable_h
|
|
#define vtkEdgeTable_h
|
|
|
|
#include "vtkCommonDataModelModule.h" // For export macro
|
|
#include "vtkObject.h"
|
|
|
|
class vtkIdList;
|
|
class vtkPoints;
|
|
class vtkVoidArray;
|
|
|
|
class VTKCOMMONDATAMODEL_EXPORT vtkEdgeTable : public vtkObject
|
|
{
|
|
public:
|
|
/**
|
|
* Instantiate object assuming that 1000 edges are to be inserted.
|
|
*/
|
|
static vtkEdgeTable* New();
|
|
|
|
vtkTypeMacro(vtkEdgeTable, vtkObject);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
/**
|
|
* Free memory and return to the initially instantiated state.
|
|
*/
|
|
void Initialize();
|
|
|
|
/**
|
|
* Initialize the edge insertion process. Provide an estimate of the number
|
|
* of points in a dataset (the maximum range value of p1 or p2). The
|
|
* storeAttributes variable controls whether attributes are to be stored
|
|
* with the edge, and what type of attributes. If storeAttributes==1, then
|
|
* attributes of vtkIdType can be stored. If storeAttributes==2, then
|
|
* attributes of type void* can be stored. In either case, additional
|
|
* memory will be required by the data structure to store attribute data
|
|
* per each edge. This method is used in conjunction with one of the three
|
|
* InsertEdge() methods described below (don't mix the InsertEdge()
|
|
* methods---make sure that the one used is consistent with the
|
|
* storeAttributes flag set in InitEdgeInsertion()).
|
|
*/
|
|
int InitEdgeInsertion(vtkIdType numPoints, int storeAttributes = 0);
|
|
|
|
/**
|
|
* Insert the edge (p1,p2) into the table. It is the user's
|
|
* responsibility to check if the edge has already been inserted
|
|
* (use IsEdge()). If the storeAttributes flag in InitEdgeInsertion()
|
|
* has been set, then the method returns a unique integer id (i.e.,
|
|
* the edge id) that can be used to set and get edge
|
|
* attributes. Otherwise, the method will return 1. Do not mix this
|
|
* method with the InsertEdge() method that follows.
|
|
*/
|
|
vtkIdType InsertEdge(vtkIdType p1, vtkIdType p2);
|
|
|
|
/**
|
|
* Insert the edge (p1,p2) into the table with the attribute id
|
|
* specified (make sure the attributeId >= 0). Note that the
|
|
* attributeId is ignored if the storeAttributes variable was set to
|
|
* 0 in the InitEdgeInsertion() method. It is the user's
|
|
* responsibility to check if the edge has already been inserted
|
|
* (use IsEdge()). Do not mix this method with the other two
|
|
* InsertEdge() methods.
|
|
*/
|
|
void InsertEdge(vtkIdType p1, vtkIdType p2, vtkIdType attributeId);
|
|
|
|
/**
|
|
* Insert the edge (p1,p2) into the table with the attribute id
|
|
* specified (make sure the attributeId >= 0). Note that the
|
|
* attributeId is ignored if the storeAttributes variable was set to
|
|
* 0 in the InitEdgeInsertion() method. It is the user's
|
|
* responsibility to check if the edge has already been inserted
|
|
* (use IsEdge()). Do not mix this method with the other two
|
|
* InsertEdge() methods.
|
|
*/
|
|
void InsertEdge(vtkIdType p1, vtkIdType p2, void* ptr);
|
|
|
|
/**
|
|
* Return an integer id for the edge, or an attribute id of the edge
|
|
* (p1,p2) if the edge has been previously defined (it depends upon
|
|
* which version of InsertEdge() is being used); otherwise -1. The
|
|
* unique integer id can be used to set and retrieve attributes to
|
|
* the edge.
|
|
*/
|
|
vtkIdType IsEdge(vtkIdType p1, vtkIdType p2);
|
|
|
|
/**
|
|
* Similar to above, but returns a void* pointer is InitEdgeInsertion()
|
|
* has been called with storeAttributes==2. A nullptr pointer value
|
|
* is returned if the edge does not exist.
|
|
*/
|
|
void IsEdge(vtkIdType p1, vtkIdType p2, void*& ptr);
|
|
|
|
/**
|
|
* Initialize the point insertion process. The newPts is an object
|
|
* representing point coordinates into which incremental insertion methods
|
|
* place their data. The points are associated with the edge.
|
|
*/
|
|
int InitPointInsertion(vtkPoints* newPts, vtkIdType estSize);
|
|
|
|
/**
|
|
* Insert a unique point on the specified edge. Invoke this method only
|
|
* after InitPointInsertion() has been called. Return 0 if point was
|
|
* already in the list, otherwise return 1.
|
|
*/
|
|
int InsertUniquePoint(vtkIdType p1, vtkIdType p2, double x[3], vtkIdType& ptId);
|
|
|
|
//@{
|
|
/**
|
|
* Return the number of edges that have been inserted thus far.
|
|
*/
|
|
vtkGetMacro(NumberOfEdges, vtkIdType);
|
|
//@}
|
|
|
|
/**
|
|
* Initialize traversal of edges in table.
|
|
*/
|
|
void InitTraversal();
|
|
|
|
/**
|
|
* Traverse list of edges in table. Return the edge as (p1,p2), where p1
|
|
* and p2 are point id's. Method return value is <0 if list is exhausted;
|
|
* non-zero otherwise. The value of p1 is guaranteed to be <= p2.
|
|
*/
|
|
vtkIdType GetNextEdge(vtkIdType& p1, vtkIdType& p2);
|
|
|
|
/**
|
|
* Similar to above, but fills a void* pointer if InitEdgeInsertion()
|
|
* has been called with storeAttributes==2. A nullptr pointer value
|
|
* is filled otherwise. Returns 0 if list is exhausted.
|
|
*/
|
|
int GetNextEdge(vtkIdType& p1, vtkIdType& p2, void*& ptr);
|
|
|
|
/**
|
|
* Reset the object and prepare for reinsertion of edges. Does not delete
|
|
* memory like the Initialize() method.
|
|
*/
|
|
void Reset();
|
|
|
|
protected:
|
|
vtkEdgeTable();
|
|
~vtkEdgeTable() override;
|
|
|
|
vtkIdList** Table;
|
|
vtkIdType TableMaxId; // maximum point id inserted
|
|
vtkIdType TableSize; // allocated size of table
|
|
int Position[2];
|
|
int Extend;
|
|
vtkIdType NumberOfEdges;
|
|
vtkPoints* Points; // support point insertion
|
|
|
|
int StoreAttributes; //==0:no attributes stored;==1:vtkIdType;==2:void*
|
|
vtkIdList** Attributes; // used to store IdTypes attributes
|
|
vtkVoidArray** PointerAttributes; // used to store void* pointers
|
|
|
|
vtkIdList** Resize(vtkIdType size);
|
|
|
|
private:
|
|
vtkEdgeTable(const vtkEdgeTable&) = delete;
|
|
void operator=(const vtkEdgeTable&) = delete;
|
|
};
|
|
|
|
#endif
|