VTK  9.0.2
vtkXMLWriter.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkXMLWriter.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
30 #ifndef vtkXMLWriter_h
31 #define vtkXMLWriter_h
32 
33 #include "vtkAlgorithm.h"
34 #include "vtkIOXMLModule.h" // For export macro
35 
36 #include <sstream> // For ostringstream ivar
37 
38 class vtkAbstractArray;
39 class vtkArrayIterator;
40 
41 template <class T>
43 
44 class vtkCellData;
45 class vtkDataArray;
46 class vtkDataCompressor;
47 class vtkDataSet;
49 class vtkFieldData;
50 class vtkOutputStream;
51 class vtkPointData;
52 class vtkPoints;
53 class vtkFieldData;
54 class vtkXMLDataHeader;
55 
56 class vtkStdString;
57 class OffsetsManager; // one per piece/per time
58 class OffsetsManagerGroup; // array of OffsetsManager
59 class OffsetsManagerArray; // array of OffsetsManagerGroup
60 
61 class VTKIOXML_EXPORT vtkXMLWriter : public vtkAlgorithm
62 {
63 public:
64  vtkTypeMacro(vtkXMLWriter, vtkAlgorithm);
65  void PrintSelf(ostream& os, vtkIndent indent) override;
66 
70  enum
71  {
73  LittleEndian
74  };
75 
82  enum
83  {
86  Appended
87  };
88 
94  enum
95  {
96  Int32 = 32,
97  Int64 = 64
98  };
99 
105  enum
106  {
107  UInt32 = 32,
108  UInt64 = 64
109  };
110 
112 
116  vtkSetMacro(ByteOrder, int);
117  vtkGetMacro(ByteOrder, int);
121 
123 
127  virtual void SetHeaderType(int);
128  vtkGetMacro(HeaderType, int);
132 
134 
138  virtual void SetIdType(int);
139  vtkGetMacro(IdType, int);
143 
145 
148  vtkSetStringMacro(FileName);
149  vtkGetStringMacro(FileName);
151 
153 
156  vtkSetMacro(WriteToOutputString, vtkTypeBool);
157  vtkGetMacro(WriteToOutputString, vtkTypeBool);
158  vtkBooleanMacro(WriteToOutputString, vtkTypeBool);
159  std::string GetOutputString() { return this->OutputString; }
161 
163 
168  vtkGetObjectMacro(Compressor, vtkDataCompressor);
170 
172  {
176  LZMA
177  };
178 
180 
183  void SetCompressorType(int compressorType);
184  void SetCompressorTypeToNone() { this->SetCompressorType(NONE); }
185  void SetCompressorTypeToLZ4() { this->SetCompressorType(LZ4); }
186  void SetCompressorTypeToZLib() { this->SetCompressorType(ZLIB); }
187  void SetCompressorTypeToLZMA() { this->SetCompressorType(LZMA); }
188 
189  void SetCompressionLevel(int compressorLevel);
190  vtkGetMacro(CompressionLevel, int);
192 
194 
200  virtual void SetBlockSize(size_t blockSize);
201  vtkGetMacro(BlockSize, size_t);
203 
205 
210  vtkSetMacro(DataMode, int);
211  vtkGetMacro(DataMode, int);
216 
218 
225  vtkSetMacro(EncodeAppendedData, vtkTypeBool);
226  vtkGetMacro(EncodeAppendedData, vtkTypeBool);
227  vtkBooleanMacro(EncodeAppendedData, vtkTypeBool);
229 
231 
239  vtkDataObject* GetInput() { return this->GetInput(0); }
241 
245  virtual const char* GetDefaultFileExtension() = 0;
246 
250  int Write();
251 
252  // See the vtkAlgorithm for a description of what these do
254  vtkInformationVector* outputVector) override;
255 
257 
260  vtkGetMacro(NumberOfTimeSteps, int);
261  vtkSetMacro(NumberOfTimeSteps, int);
263 
265 
268  void Start();
269  void Stop();
270  void WriteNextTime(double time);
272 
273 protected:
275  ~vtkXMLWriter() override;
276 
277  virtual int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
278  vtkInformationVector* outputVector);
279  virtual int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
280  vtkInformationVector* outputVector);
281 
282  // The name of the output file.
283  char* FileName;
284 
285  // The output stream to which the XML is written.
286  ostream* Stream;
287 
288  // Whether this object is writing to a string or a file.
289  // Default is 0: write to file.
291 
292  // The output string.
294 
295  // The output byte order.
297 
298  // The output binary header word type.
300 
301  // The output vtkIdType.
302  int IdType;
303 
304  // The form of binary data to write. Used by subclasses to choose
305  // how to write data.
306  int DataMode;
307 
308  // Whether to base64-encode the appended data section.
310 
311  // The stream position at which appended data starts.
312  vtkTypeInt64 AppendedDataPosition;
313 
314  // appended data offsets for field data
315  OffsetsManagerGroup* FieldDataOM; // one per array
316 
317  // We need a 32 bit signed integer type to which vtkIdType will be
318  // converted if Int32 is specified for the IdType parameter to this
319  // writer.
320 #if VTK_SIZEOF_SHORT == 4
321  typedef short Int32IdType;
322 #elif VTK_SIZEOF_INT == 4
323  typedef int Int32IdType;
324 #elif VTK_SIZEOF_LONG == 4
325  typedef long Int32IdType;
326 #else
327 #error "No native data type can represent a signed 32-bit integer."
328 #endif
329 
330  // Buffer for vtkIdType conversion.
331  Int32IdType* Int32IdTypeBuffer;
332 
333  // The byte swapping buffer.
334  unsigned char* ByteSwapBuffer;
335 
336  // Compression information.
338  size_t BlockSize;
342  // Compression Level for vtkDataCompressor objects
343  // 1 (worst compression, fastest) ... 9 (best compression, slowest)
344  int CompressionLevel = 5;
345 
346  // The output stream used to write binary and appended data. May
347  // transparently encode the data.
349 
350  // Allow subclasses to set the data stream.
352  vtkGetObjectMacro(DataStream, vtkOutputStream);
353 
354  // Method to drive most of actual writing.
355  virtual int WriteInternal();
356 
357  // Method defined by subclasses to write data. Return 1 for
358  // success, 0 for failure.
359  virtual int WriteData() { return 1; }
360 
361  // Method defined by subclasses to specify the data set's type name.
362  virtual const char* GetDataSetName() = 0;
363 
364  // Methods to define the file's major and minor version numbers.
365  virtual int GetDataSetMajorVersion();
366  virtual int GetDataSetMinorVersion();
367 
368  // Utility methods for subclasses.
370  virtual int StartFile();
371  virtual void WriteFileAttributes();
372  virtual int EndFile();
373  void DeleteAFile();
374  void DeleteAFile(const char* name);
375 
376  virtual int WritePrimaryElement(ostream& os, vtkIndent indent);
377  virtual void WritePrimaryElementAttributes(ostream& os, vtkIndent indent);
380 
381  // Write enough space to go back and write the given attribute with
382  // at most "length" characters in the value. Returns the stream
383  // position at which attribute should be later written. The default
384  // length of 20 is enough for a 64-bit integer written in decimal or
385  // a double-precision floating point value written to 13 digits of
386  // precision (the other 7 come from a minus sign, decimal place, and
387  // a big exponent like "e+300").
388  vtkTypeInt64 ReserveAttributeSpace(const char* attr, size_t length = 20);
389 
390  vtkTypeInt64 GetAppendedDataOffset();
392  vtkTypeInt64 streamPos, vtkTypeInt64& lastoffset, const char* attr = nullptr);
394  vtkTypeInt64 streamPos, vtkTypeInt64 offset, const char* attr = nullptr);
395  void ForwardAppendedDataDouble(vtkTypeInt64 streamPos, double value, const char* attr);
396 
397  int WriteScalarAttribute(const char* name, int data);
398  int WriteScalarAttribute(const char* name, float data);
399  int WriteScalarAttribute(const char* name, double data);
400 #ifdef VTK_USE_64BIT_IDS
401  int WriteScalarAttribute(const char* name, vtkIdType data);
402 #endif
403 
404  int WriteVectorAttribute(const char* name, int length, int* data);
405  int WriteVectorAttribute(const char* name, int length, float* data);
406  int WriteVectorAttribute(const char* name, int length, double* data);
407 #ifdef VTK_USE_64BIT_IDS
408  int WriteVectorAttribute(const char* name, int length, vtkIdType* data);
409 #endif
410 
411  int WriteDataModeAttribute(const char* name);
412  int WriteWordTypeAttribute(const char* name, int dataType);
413  int WriteStringAttribute(const char* name, const char* value);
414 
415  // Returns true if any keys were written.
417 
418  void WriteArrayHeader(vtkAbstractArray* a, vtkIndent indent, const char* alternateName,
419  int writeNumTuples, int timestep);
420  virtual void WriteArrayFooter(
421  ostream& os, vtkIndent indent, vtkAbstractArray* a, int shortFormat);
422  virtual void WriteArrayInline(vtkAbstractArray* a, vtkIndent indent,
423  const char* alternateName = nullptr, int writeNumTuples = 0);
424  virtual void WriteInlineData(vtkAbstractArray* a, vtkIndent indent);
425 
427  const char* alternateName = nullptr, int writeNumTuples = 0, int timestep = 0);
431  void WriteArrayAppendedData(vtkAbstractArray* a, vtkTypeInt64 pos, vtkTypeInt64& lastoffset);
432 
433  // Methods for writing points, point data, and cell data.
434  void WriteFieldData(vtkIndent indent);
439  void WriteFieldDataAppendedData(vtkFieldData* fd, int timestep, OffsetsManagerGroup* fdManager);
441  void WritePointDataAppendedData(vtkPointData* pd, int timestep, OffsetsManagerGroup* pdManager);
443  void WriteCellDataAppendedData(vtkCellData* cd, int timestep, OffsetsManagerGroup* cdManager);
444  void WriteAttributeIndices(vtkDataSetAttributes* dsa, char** names);
446  void WritePointsAppendedData(vtkPoints* points, int timestep, OffsetsManager* pdManager);
449  vtkDataArray* xc, vtkDataArray* yc, vtkDataArray* zc, vtkIndent indent);
451  vtkIndent indent, OffsetsManagerGroup* coordManager);
453  int timestep, OffsetsManagerGroup* coordManager);
457  void WritePArray(vtkAbstractArray* a, vtkIndent indent, const char* alternateName = nullptr);
459 
460  // Internal utility methods.
461  int WriteBinaryDataBlock(unsigned char* in_data, size_t numWords, int wordType);
462  void PerformByteSwap(void* data, size_t numWords, size_t wordSize);
464  int WriteCompressionBlock(unsigned char* data, size_t size);
466  size_t GetWordTypeSize(int dataType);
467  const char* GetWordTypeName(int dataType);
468  size_t GetOutputWordTypeSize(int dataType);
469 
470  char** CreateStringArray(int numStrings);
471  void DestroyStringArray(int numStrings, char** strings);
472 
473  // The current range over which progress is moving. This allows for
474  // incrementally fine-tuned progress updates.
475  virtual void GetProgressRange(float range[2]);
476  virtual void SetProgressRange(const float range[2], int curStep, int numSteps);
477  virtual void SetProgressRange(const float range[2], int curStep, const float* fractions);
478  virtual void SetProgressPartial(float fraction);
479  virtual void UpdateProgressDiscrete(float progress);
480  float ProgressRange[2];
481 
482  // This shallows copy input field data to the passed field data and
483  // then adds any additional field arrays. For example, TimeValue.
485 
486  ostream* OutFile;
487  std::ostringstream* OutStringStream;
488 
489  int OpenStream();
490  int OpenFile();
491  int OpenString();
492  void CloseStream();
493  void CloseFile();
494  void CloseString();
495 
496  // The timestep currently being written
499 
500  // Dummy boolean var to start/stop the continue executing:
501  // when using the Start/Stop/WriteNextTime API
502  int UserContinueExecuting; // can only be -1 = invalid, 0 = stop, 1 = start
503 
504  // This variable is used to ease transition to new versions of VTK XML files.
505  // If data that needs to be written satisfies certain conditions,
506  // the writer can use the previous file version version.
507  // For version change 0.1 -> 2.0 (UInt32 header) and 1.0 -> 2.0
508  // (UInt64 header), if data does not have a vtkGhostType array,
509  // the file is written with version: 0.1/1.0.
511 
512  vtkTypeInt64* NumberOfTimeValues; // one per piece / per timestep
513 
514  friend class vtkXMLWriterHelper;
515 
516 private:
517  vtkXMLWriter(const vtkXMLWriter&) = delete;
518  void operator=(const vtkXMLWriter&) = delete;
519 };
520 
521 #endif
Helper class due to PIMPL excess.
Abstract superclass for all arrays.
Superclass for all sources, filters, and sinks in VTK.
Definition: vtkAlgorithm.h:63
Implementation template for a array iterator.
Abstract superclass to iterate over elements in an vtkAbstractArray.
represent and manipulate cell attribute data
Definition: vtkCellData.h:33
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
Abstract interface for data compression classes.
general representation of visualization data
Definition: vtkDataObject.h:60
represent and manipulate attribute data in a dataset
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
represent and manipulate fields of data
Definition: vtkFieldData.h:54
a simple class to control print indentation
Definition: vtkIndent.h:34
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
Wraps a binary output stream with a VTK interface.
represent and manipulate point attribute data
Definition: vtkPointData.h:32
represent and manipulate 3D points
Definition: vtkPoints.h:34
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:35
Superclass for VTK's XML file writers.
Definition: vtkXMLWriter.h:62
virtual int GetDataSetMajorVersion()
void EndAppendedData()
bool UsePreviousVersion
Definition: vtkXMLWriter.h:510
int WriteBinaryDataInternal(vtkAbstractArray *a)
int CurrentTimeIndex
Definition: vtkXMLWriter.h:497
int WriteBinaryDataBlock(unsigned char *in_data, size_t numWords, int wordType)
void WriteFieldData(vtkIndent indent)
void SetInputData(vtkDataObject *)
Assign a data object as input.
void SetCompressorTypeToLZ4()
Definition: vtkXMLWriter.h:185
virtual int GetDataSetMinorVersion()
virtual void SetCompressor(vtkDataCompressor *)
Get/Set the compressor used to compress binary and appended data before writing to the file.
ostream * OutFile
Definition: vtkXMLWriter.h:486
vtkTypeBool WriteToOutputString
Definition: vtkXMLWriter.h:290
void SetByteOrderToLittleEndian()
void SetCompressorTypeToZLib()
Definition: vtkXMLWriter.h:186
int WriteBinaryData(vtkAbstractArray *a)
unsigned char * ByteSwapBuffer
Definition: vtkXMLWriter.h:334
void WritePCellData(vtkCellData *cd, vtkIndent indent)
vtkDataObject * GetInput(int port)
int UserContinueExecuting
Definition: vtkXMLWriter.h:502
void SetCompressorTypeToLZMA()
Definition: vtkXMLWriter.h:187
vtkTypeBool EncodeAppendedData
Definition: vtkXMLWriter.h:309
vtkDataObject * GetInput()
Definition: vtkXMLWriter.h:239
void WriteArrayAppendedData(vtkAbstractArray *a, vtkTypeInt64 pos, vtkTypeInt64 &lastoffset)
int WriteCompressionHeader()
void WriteFieldDataAppendedData(vtkFieldData *fd, int timestep, OffsetsManagerGroup *fdManager)
size_t BlockSize
Definition: vtkXMLWriter.h:338
int WriteScalarAttribute(const char *name, int data)
void DestroyStringArray(int numStrings, char **strings)
vtkXMLDataHeader * CompressionHeader
Definition: vtkXMLWriter.h:340
void ForwardAppendedDataDouble(vtkTypeInt64 streamPos, double value, const char *attr)
void WritePointDataAppended(vtkPointData *pd, vtkIndent indent, OffsetsManagerGroup *pdManager)
int NumberOfTimeSteps
Definition: vtkXMLWriter.h:498
void DeleteAFile()
int Write()
Invoke the writer.
void WritePPointData(vtkPointData *pd, vtkIndent indent)
char * FileName
Definition: vtkXMLWriter.h:283
void WritePPoints(vtkPoints *points, vtkIndent indent)
vtkTypeInt64 AppendedDataPosition
Definition: vtkXMLWriter.h:312
void SetCompressorTypeToNone()
Definition: vtkXMLWriter.h:184
void WriteFieldDataAppended(vtkFieldData *fd, vtkIndent indent, OffsetsManagerGroup *fdManager)
std::string OutputString
Definition: vtkXMLWriter.h:293
int WriteStringAttribute(const char *name, const char *value)
bool WriteInformation(vtkInformation *info, vtkIndent indent)
~vtkXMLWriter() override
virtual int WriteData()
Definition: vtkXMLWriter.h:359
int WriteCompressionBlock(unsigned char *data, size_t size)
void SetDataModeToBinary()
size_t GetOutputWordTypeSize(int dataType)
void UpdateFieldData(vtkFieldData *)
std::ostringstream * OutStringStream
Definition: vtkXMLWriter.h:487
int WriteVectorAttribute(const char *name, int length, int *data)
void SetInputData(int, vtkDataObject *)
virtual void UpdateProgressDiscrete(float progress)
virtual int EndFile()
void ForwardAppendedDataOffset(vtkTypeInt64 streamPos, vtkTypeInt64 offset, const char *attr=nullptr)
void WritePointsAppended(vtkPoints *points, vtkIndent indent, OffsetsManager *manager)
int WriteVectorAttribute(const char *name, int length, float *data)
int WriteDataModeAttribute(const char *name)
void WritePArray(vtkAbstractArray *a, vtkIndent indent, const char *alternateName=nullptr)
void Start()
API to interface an outside the VTK pipeline control.
void WritePointsAppendedData(vtkPoints *points, int timestep, OffsetsManager *pdManager)
void WriteCoordinatesAppendedData(vtkDataArray *xc, vtkDataArray *yc, vtkDataArray *zc, int timestep, OffsetsManagerGroup *coordManager)
Int32IdType * Int32IdTypeBuffer
Definition: vtkXMLWriter.h:331
void SetDataModeToAppended()
void SetCompressorType(int compressorType)
Convenience functions to set the compressor to certain known types.
void WriteArrayHeader(vtkAbstractArray *a, vtkIndent indent, const char *alternateName, int writeNumTuples, int timestep)
virtual void WriteArrayInline(vtkAbstractArray *a, vtkIndent indent, const char *alternateName=nullptr, int writeNumTuples=0)
void WritePointsInline(vtkPoints *points, vtkIndent indent)
virtual void SetProgressRange(const float range[2], int curStep, const float *fractions)
void SetHeaderTypeToUInt32()
vtkTypeInt64 GetAppendedDataOffset()
void WriteCellDataAppendedData(vtkCellData *cd, int timestep, OffsetsManagerGroup *cdManager)
virtual void SetDataStream(vtkOutputStream *)
int WriteVectorAttribute(const char *name, int length, double *data)
vtkTypeBool ProcessRequest(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override
Upstream/Downstream requests form the generalized interface through which executives invoke a algorit...
void SetHeaderTypeToUInt64()
int WriteScalarAttribute(const char *name, double data)
void WriteCellDataAppended(vtkCellData *cd, vtkIndent indent, OffsetsManagerGroup *cdManager)
virtual void WriteFileAttributes()
void CloseStream()
vtkDataSet * GetInputAsDataSet()
void WritePCoordinates(vtkDataArray *xc, vtkDataArray *yc, vtkDataArray *zc, vtkIndent indent)
void WriteCoordinatesInline(vtkDataArray *xc, vtkDataArray *yc, vtkDataArray *zc, vtkIndent indent)
void SetByteOrderToBigEndian()
vtkTypeInt64 * NumberOfTimeValues
Definition: vtkXMLWriter.h:512
void WriteCoordinatesAppended(vtkDataArray *xc, vtkDataArray *yc, vtkDataArray *zc, vtkIndent indent, OffsetsManagerGroup *coordManager)
size_t CompressionBlockNumber
Definition: vtkXMLWriter.h:339
vtkOutputStream * DataStream
Definition: vtkXMLWriter.h:348
void WriteFieldDataInline(vtkFieldData *fd, vtkIndent indent)
void SetIdTypeToInt32()
void CloseFile()
void WritePointDataInline(vtkPointData *pd, vtkIndent indent)
int OpenStream()
std::string GetOutputString()
Definition: vtkXMLWriter.h:159
void WriteArrayAppended(vtkAbstractArray *a, vtkIndent indent, OffsetsManager &offs, const char *alternateName=nullptr, int writeNumTuples=0, int timestep=0)
ostream * Stream
Definition: vtkXMLWriter.h:286
OffsetsManagerGroup * FieldDataOM
Definition: vtkXMLWriter.h:315
const char * GetWordTypeName(int dataType)
int OpenString()
virtual void GetProgressRange(float range[2])
vtkTypeInt64 ReserveAttributeSpace(const char *attr, size_t length=20)
void SetCompressionLevel(int compressorLevel)
virtual void SetProgressRange(const float range[2], int curStep, int numSteps)
virtual void WriteInlineData(vtkAbstractArray *a, vtkIndent indent)
int CreateCompressionHeader(size_t size)
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkDataCompressor * Compressor
Definition: vtkXMLWriter.h:337
virtual const char * GetDataSetName()=0
virtual int WritePrimaryElement(ostream &os, vtkIndent indent)
virtual const char * GetDefaultFileExtension()=0
Get the default file extension for files written by this writer.
virtual void SetProgressPartial(float fraction)
virtual int StartFile()
int WriteScalarAttribute(const char *name, float data)
void WriteNextTime(double time)
void DeleteAFile(const char *name)
void SetIdTypeToInt64()
void WritePointDataAppendedData(vtkPointData *pd, int timestep, OffsetsManagerGroup *pdManager)
virtual void SetBlockSize(size_t blockSize)
Get/Set the block size used in compression.
void StartAppendedData()
virtual void SetIdType(int)
Get/Set the size of the vtkIdType values stored in the file.
void CloseString()
vtkTypeInt64 CompressionHeaderPosition
Definition: vtkXMLWriter.h:341
void SetDataModeToAscii()
void WriteAppendedDataOffset(vtkTypeInt64 streamPos, vtkTypeInt64 &lastoffset, const char *attr=nullptr)
void WriteAttributeIndices(vtkDataSetAttributes *dsa, char **names)
int WriteAsciiData(vtkAbstractArray *a, vtkIndent indent)
char ** CreateStringArray(int numStrings)
virtual void WriteArrayFooter(ostream &os, vtkIndent indent, vtkAbstractArray *a, int shortFormat)
size_t GetWordTypeSize(int dataType)
virtual int RequestInformation(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
virtual void WritePrimaryElementAttributes(ostream &os, vtkIndent indent)
virtual void SetHeaderType(int)
Get/Set the binary data header word type.
virtual int WriteInternal()
void WriteCellDataInline(vtkCellData *cd, vtkIndent indent)
int WriteWordTypeAttribute(const char *name, int dataType)
virtual int RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
void PerformByteSwap(void *data, size_t numWords, size_t wordSize)
@ points
Definition: vtkX3D.h:452
@ info
Definition: vtkX3D.h:382
@ length
Definition: vtkX3D.h:399
@ value
Definition: vtkX3D.h:226
@ port
Definition: vtkX3D.h:453
@ range
Definition: vtkX3D.h:244
@ time
Definition: vtkX3D.h:503
@ name
Definition: vtkX3D.h:225
@ size
Definition: vtkX3D.h:259
@ offset
Definition: vtkX3D.h:444
@ progress
Definition: vtkX3D.h:458
@ data
Definition: vtkX3D.h:321
@ string
Definition: vtkX3D.h:496
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:338