1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile: vtkSimpleScalarTree.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.
=========================================================================*/
// .NAME vtkSimpleScalarTree - organize data according to scalar values (used to accelerate contouring operations)
// .SECTION Description
// vtkSimpleScalarTree creates a pointerless binary tree that helps search for
// cells that lie within a particular scalar range. This object is used to
// accelerate some contouring (and other scalar-based techniques).
//
// The tree consists of an array of (min,max) scalar range pairs per node in
// the tree. The (min,max) range is determined from looking at the range of
// the children of the tree node. If the node is a leaf, then the range is
// determined by scanning the range of scalar data in n cells in the
// dataset. The n cells are determined by arbitrary selecting cell ids from
// id(i) to id(i+n), and where n is specified using the BranchingFactor
// ivar. Note that leaf node i=0 contains the scalar range computed from
// cell ids (0,n-1); leaf node i=1 contains the range from cell ids (n,2n-1);
// and so on. The implication is that there are no direct lists of cell ids
// per leaf node, instead the cell ids are implicitly known.
#ifndef __vtkSimpleScalarTree_h
#define __vtkSimpleScalarTree_h
#include "vtkScalarTree.h"
//BTX
class vtkScalarNode;
//ETX
class VTK_FILTERING_EXPORT vtkSimpleScalarTree : public vtkScalarTree
{
public:
// Description:
// Instantiate scalar tree with maximum level of 20 and branching
// factor of 5.
static vtkSimpleScalarTree *New();
// Description:
// Standard type related macros and PrintSelf() method.
vtkTypeRevisionMacro(vtkSimpleScalarTree,vtkScalarTree);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Set the branching factor for the tree. This is the number of
// children per tree node. Smaller values (minimum is 2) mean deeper
// trees and more memory overhead. Larger values mean shallower
// trees, less memory usage, but worse performance.
vtkSetClampMacro(BranchingFactor,int,2,VTK_LARGE_INTEGER);
vtkGetMacro(BranchingFactor,int);
// Description:
// Get the level of the scalar tree. This value may change each time the
// scalar tree is built and the branching factor changes.
vtkGetMacro(Level,int);
// Description:
// Set the maximum allowable level for the tree.
vtkSetClampMacro(MaxLevel,int,1,VTK_LARGE_INTEGER);
vtkGetMacro(MaxLevel,int);
// Description:
// Construct the scalar tree from the dataset provided. Checks build times
// and modified time from input and reconstructs the tree if necessary.
virtual void BuildTree();
// Description:
// Initialize locator. Frees memory and resets object as appropriate.
virtual void Initialize();
// Description:
// Begin to traverse the cells based on a scalar value. Returned cells
// will have scalar values that span the scalar value specified.
virtual void InitTraversal(double scalarValue);
// Description:
// Return the next cell that may contain scalar value specified to
// initialize traversal. The value NULL is returned if the list is
// exhausted. Make sure that InitTraversal() has been invoked first or
// you'll get erratic behavior.
virtual vtkCell *GetNextCell(vtkIdType &cellId, vtkIdList* &ptIds,
vtkDataArray *cellScalars);
protected:
vtkSimpleScalarTree();
~vtkSimpleScalarTree();
vtkDataArray *Scalars;
int MaxLevel;
int Level;
int BranchingFactor; //number of children per node
vtkScalarNode *Tree; //pointerless scalar range tree
int TreeSize; //allocated size of tree
private:
vtkIdType TreeIndex; //traversal location within tree
vtkIdType LeafOffset; //offset to leaf nodes of tree
int ChildNumber; //current child in traversal
vtkIdType CellId; //current cell id being examined
int FindStartLeaf(vtkIdType index, int level);
int FindNextLeaf(vtkIdType index,int level);
private:
vtkSimpleScalarTree(const vtkSimpleScalarTree&); // Not implemented.
void operator=(const vtkSimpleScalarTree&); // Not implemented.
};
#endif
|
