vtkTable.h 7.55 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkTable.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.

=========================================================================*/
15
16
17
18
19
/*-------------------------------------------------------------------------
  Copyright 2008 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
20
21
22
23
// .NAME vtkTable - A table, which contains similar-typed columns of data
//
// .SECTION Description
// vtkTable is a basic data structure for storing columns of data.
24
25
// Internally, columns are stored in a vtkDataSetAttributes structure called
// RowData. However, using the vtkTable API additionally ensures that every column
26
27
28
// has the same number of entries, and provides row access (using vtkVariantArray)
// and single entry access (using vtkVariant).
//
29
30
31
// The field data inherited from vtkDataObject may be used to store metadata
// related to the table.
//
32
// .SECTION Caveats
33
34
35
36
// You should use the vtkTable API to change the table data. Performing
// operations on the object returned by GetRowData() may
// yield unexpected results. vtkTable does allow the user to set the field
// data using SetRowData(); the number of rows in the table is determined
37
38
39
// by the number of tuples in the first array (it is assumed that all arrays
// are the same length).
//
40
41
42
// Each column added with AddColumn <b>must</b> have its name set to a unique,
// non-empty string in order for GetValue() to function properly.
//
43
44
45
46
47
48
49
50
51
52
// .SECTION Thanks
// Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from
// Sandia National Laboratories for their help in developing this class API.

#ifndef __vtkTable_h
#define __vtkTable_h

#include "vtkDataObject.h"

class vtkAbstractArray;
53
class vtkDataSetAttributes;
54
55
56
57
58
59
60
class vtkVariant;
class vtkVariantArray;

class VTK_FILTERING_EXPORT vtkTable : public vtkDataObject
{
public:
  static vtkTable* New();
61
  vtkTypeMacro(vtkTable, vtkDataObject);
62
63
  void PrintSelf(ostream &os, vtkIndent indent);

64
  // Description:
65
66
67
68
69
  // Dump table contents.  If rowLimit is -1 then the full table
  // is printed out (Default).  If rowLimit is 0 then only the
  // header row will be displayed.  Otherwise, if rowLimit > 0
  // then Dump will print the first rowLimit rows of data.
  void Dump( unsigned int colWidth = 16, int rowLimit = -1 );
70

71
72
73
74
  // Description:
  // Return what type of dataset this is.
  int GetDataObjectType() {return VTK_TABLE;}

75
  // Description:
76
77
78
79
80
81
82
83
84
85
86
  // Return the actual size of the data in kilobytes. This number
  // is valid only after the pipeline has updated. The memory size
  // returned is guaranteed to be greater than or equal to the
  // memory required to represent the data (e.g., extra space in
  // arrays, etc. are not included in the return value).
  virtual unsigned long GetActualMemorySize();

  // Description:
  // Get/Set the main data (columns) of the table.
  vtkGetObjectMacro(RowData, vtkDataSetAttributes);
  virtual void SetRowData(vtkDataSetAttributes* data);
87

88
89
90
91
92
93
94
95
  //
  // Row functions
  //

  // Description:
  // Get the number of rows in the table.
  vtkIdType GetNumberOfRows();

96
97
98
99
100
  // Description:
  // Set the number of rows in the table. Note that memory allocation might be performed
  // as a result of this, but no memory will be released. 
  void SetNumberOfRows(const vtkIdType );

101
102
  // Description:
  // Get a row of the table as a vtkVariantArray which has one entry for each column.
103
  // NOTE: This version of the method is NOT thread safe.
104
105
  vtkVariantArray* GetRow(vtkIdType row);

106
107
108
109
  // Description:
  // Get a row of the table as a vtkVariantArray which has one entry for each column.
  void GetRow(vtkIdType row, vtkVariantArray *values);

Jeff Baumes's avatar
Jeff Baumes committed
110
111
  // Description:
  // Set a row of the table with a vtkVariantArray which has one entry for each column.
112
  void SetRow(vtkIdType row, vtkVariantArray *values);
Jeff Baumes's avatar
Jeff Baumes committed
113

114
115
  // Description:
  // Insert a blank row at the end of the table.
116
  vtkIdType InsertNextBlankRow(double default_num_val=0.0);
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

  // Description:
  // Insert a row specified by a vtkVariantArray.  The number of entries in the array
  // should match the number of columns in the table.
  vtkIdType InsertNextRow(vtkVariantArray* arr);

  // Description:
  // Delete a row from the table.  Rows below the deleted row are shifted up.
  void RemoveRow(vtkIdType row);

  //
  // Column functions
  //

  // Description:
  // Get the number of columns in the table.
  vtkIdType GetNumberOfColumns();

  // Get the name of a column of the table.
  const char* GetColumnName(vtkIdType col);

  // Description:
  // Get a column of the table by its name.
  vtkAbstractArray* GetColumnByName(const char* name);

  // Description:
  // Get a column of the table by its column index.
  vtkAbstractArray* GetColumn(vtkIdType col);

  // Description:
  // Add a column to the table.
  void AddColumn(vtkAbstractArray* arr);

  // Description:
  // Remove a column from the table by its name.
  void RemoveColumnByName(const char* name);

  // Description:
  // Remove a column from the table by its column index.
  void RemoveColumn(vtkIdType col);

  //
  // Table single entry functions
  //

  // Description:
  // Retrieve a value in the table by row and column index as a variant.
164
165
166
  // Note that this calls GetValueByName internally so that each column
  // array must have its name set (and that name should be unique within
  // the table).
167
168
169
170
171
172
173
174
175
176
177
178
179
180
  vtkVariant GetValue(vtkIdType row, vtkIdType col);

  // Description:
  // Retrieve a value in the table by row index and column name as a variant.
  vtkVariant GetValueByName(vtkIdType row, const char* col);

  // Description:
  // Set a value in the table by row and column index as a variant.
  void SetValue(vtkIdType row, vtkIdType col, vtkVariant value);

  // Description:
  // Set a value in the table by row index and column name as a variant.
  void SetValueByName(vtkIdType row, const char* col, vtkVariant value);
  
181
182
183
  // Description:
  // Initialize to an empty table.
  virtual void Initialize();
184
185
186
187
188
189

  // Description:
  // Retrieve the table from vtkInformation.
  static vtkTable* GetData(vtkInformation* info);
  static vtkTable* GetData(vtkInformationVector* v, int i=0);

190
191
  // Description:
  // Shallow/deep copy the data from src into this object.
192
  virtual void ShallowCopy(vtkDataObject* src);
193
  virtual void DeepCopy(vtkDataObject* src);
194

195
196
197
198
199
200
201
202
203
204
205
  // Description:
  // Returns the attributes of the data object as a vtkFieldData.
  // This returns non-null values in all the same cases as GetAttributes,
  // in addition to the case of FIELD, which will return the field data
  // for any vtkDataObject subclass.
  virtual vtkFieldData* GetAttributesAsFieldData(int type);

  // Description:
  // Get the number of elements for a specific attribute type (ROW, etc.).
  virtual vtkIdType GetNumberOfElements(int type);

206
207
protected:
  vtkTable();
208
209
210
  ~vtkTable();

  // Description:
211
212
  // Holds the column data of the table.
  vtkDataSetAttributes* RowData;
213
214

  // Description:
215
216
  // Holds row information returned by GetRow().
  vtkVariantArray* RowArray;
217

218
private:
219
220
  vtkTable(const vtkTable&); // Not implemented
  void operator=(const vtkTable&); // Not implemented
221
222
223
224
};

#endif