/usr/include/vtk-5.8/vtkXMLReader.h is in libvtk5-dev 5.8.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 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 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 | /*=========================================================================
Program: Visualization Toolkit
Module: vtkXMLReader.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.
=========================================================================*/
// .NAME vtkXMLReader - Superclass for VTK's XML format readers.
// .SECTION Description
// vtkXMLReader uses vtkXMLDataParser to parse a VTK XML input file.
// Concrete subclasses then traverse the parsed file structure and
// extract data.
#ifndef __vtkXMLReader_h
#define __vtkXMLReader_h
#include "vtkAlgorithm.h"
class vtkAbstractArray;
class vtkCallbackCommand;
class vtkDataArraySelection;
class vtkDataSet;
class vtkDataSetAttributes;
class vtkXMLDataElement;
class vtkXMLDataParser;
class vtkInformationVector;
class vtkInformation;
class VTK_IO_EXPORT vtkXMLReader : public vtkAlgorithm
{
public:
vtkTypeMacro(vtkXMLReader,vtkAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Get/Set the name of the input file.
vtkSetStringMacro(FileName);
vtkGetStringMacro(FileName);
// Description:
// Test whether the file with the given name can be read by this
// reader.
virtual int CanReadFile(const char* name);
// Description:
// Get the output as a vtkDataSet pointer.
vtkDataSet* GetOutputAsDataSet();
vtkDataSet* GetOutputAsDataSet(int index);
// Description:
// Get the data array selection tables used to configure which data
// arrays are loaded by the reader.
vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
// Description:
// Get the number of point or cell arrays available in the input.
int GetNumberOfPointArrays();
int GetNumberOfCellArrays();
// Description:
// Get the name of the point or cell array with the given index in
// the input.
const char* GetPointArrayName(int index);
const char* GetCellArrayName(int index);
// Description:
// Get/Set whether the point or cell array with the given name is to
// be read.
int GetPointArrayStatus(const char* name);
int GetCellArrayStatus(const char* name);
void SetPointArrayStatus(const char* name, int status);
void SetCellArrayStatus(const char* name, int status);
// For the specified port, copy the information this reader sets up in
// SetupOutputInformation to outInfo
virtual void CopyOutputInformation(vtkInformation *vtkNotUsed(outInfo),
int vtkNotUsed(port)) {}
// Description:
// Which TimeStep to read.
vtkSetMacro(TimeStep, int);
vtkGetMacro(TimeStep, int);
vtkGetMacro(NumberOfTimeSteps, int);
// Description:
// Which TimeStepRange to read
vtkGetVector2Macro(TimeStepRange, int);
vtkSetVector2Macro(TimeStepRange, int);
virtual int ProcessRequest(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
protected:
vtkXMLReader();
~vtkXMLReader();
// Pipeline execution methods to be defined by subclass. Called by
// corresponding RequestData methods after appropriate setup has been
// done.
virtual int ReadXMLInformation();
virtual void ReadXMLData();
// Get the name of the data set being read.
virtual const char* GetDataSetName()=0;
// Test if the reader can read a file with the given version number.
virtual int CanReadFileVersion(int major, int minor);
// Setup the output with no data available. Used in error cases.
virtual void SetupEmptyOutput()=0;
// Setup the output's information.
virtual void SetupOutputInformation(vtkInformation *vtkNotUsed(outInfo)) {}
// Setup the output's information for the update extent
virtual void SetupUpdateExtentInformation
(vtkInformation *vtkNotUsed(outInfo)) {}
// Setup the output's data with allocation.
virtual void SetupOutputData();
// Read the primary element from the file. This is the element
// whose name is the value returned by GetDataSetName().
virtual int ReadPrimaryElement(vtkXMLDataElement* ePrimary);
// Read the top-level element from the file. This is always the
// VTKFile element.
int ReadVTKFile(vtkXMLDataElement* eVTKFile);
// Create a vtkAbstractArray from its cooresponding XML representation.
// Does not allocate.
vtkAbstractArray* CreateArray(vtkXMLDataElement* da);
// Create a vtkInformationKey from its coresponding XML representation.
// Stores it in the instance of vtkInformationProvided. Does not allocate.
int CreateInformationKey(vtkXMLDataElement *eInfoKey, vtkInformation *info);
// Internal utility methods.
virtual int OpenVTKFile();
virtual void CloseVTKFile();
virtual void CreateXMLParser();
virtual void DestroyXMLParser();
void SetupCompressor(const char* type);
int CanReadFileVersionString(const char* version);
// Returns the major version for the file being read. -1 when invalid.
vtkGetMacro(FileMajorVersion, int);
// Returns the minor version for the file being read. -1 when invalid.
vtkGetMacro(FileMinorVersion, int);
// Utility methods for subclasses.
int IntersectExtents(int* extent1, int* extent2, int* result);
int Min(int a, int b);
int Max(int a, int b);
void ComputePointDimensions(int* extent, int* dimensions);
void ComputePointIncrements(int* extent, vtkIdType* increments);
void ComputeCellDimensions(int* extent, int* dimensions);
void ComputeCellIncrements(int* extent, vtkIdType* increments);
vtkIdType GetStartTuple(int* extent, vtkIdType* increments,
int i, int j, int k);
void ReadAttributeIndices(vtkXMLDataElement* eDSA,
vtkDataSetAttributes* dsa);
char** CreateStringArray(int numStrings);
void DestroyStringArray(int numStrings, char** strings);
// Setup the data array selections for the input's set of arrays.
void SetDataArraySelections(vtkXMLDataElement* eDSA,
vtkDataArraySelection* sel);
//BTX
int SetFieldDataInfo(vtkXMLDataElement *eDSA, int association,
int numTuples, vtkInformationVector *(&infoVector));
//ETX
// Check whether the given array element is an enabled array.
int PointDataArrayIsEnabled(vtkXMLDataElement* ePDA);
int CellDataArrayIsEnabled(vtkXMLDataElement* eCDA);
// Callback registered with the SelectionObserver.
static void SelectionModifiedCallback(vtkObject* caller, unsigned long eid,
void* clientdata, void* calldata);
// The vtkXMLDataParser instance used to hide XML reading details.
vtkXMLDataParser* XMLParser;
// The FieldData element representation.
vtkXMLDataElement* FieldDataElement;
// The input file's name.
char* FileName;
// The stream used to read the input.
istream* Stream;
// The array selections.
vtkDataArraySelection* PointDataArraySelection;
vtkDataArraySelection* CellDataArraySelection;
// The observer to modify this object when the array selections are
// modified.
vtkCallbackCommand* SelectionObserver;
// Whether there was an error reading the file in RequestInformation.
int InformationError;
// Whether there was an error reading the file in RequestData.
int DataError;
// incrementally fine-tuned progress updates.
virtual void GetProgressRange(float* range);
virtual void SetProgressRange(float* range, int curStep, int numSteps);
virtual void SetProgressRange(float* range, int curStep, float* fractions);
virtual void UpdateProgressDiscrete(float progress);
float ProgressRange[2];
virtual int RequestData(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
virtual int RequestDataObject(vtkInformation *vtkNotUsed(request),
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *vtkNotUsed(outputVector))
{ return 1; }
virtual int RequestInformation(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
virtual int RequestUpdateExtentInformation
(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
vtkTimeStamp ReadMTime;
// Whether there was an error reading the XML.
int ReadError;
// For structured data keep track of dimensions empty of cells. For
// unstructured data these are always zero. This is used to support
// 1-D and 2-D cell data.
int AxesEmpty[3];
// The timestep currently being read.
int TimeStep;
int CurrentTimeStep;
int NumberOfTimeSteps;
void SetNumberOfTimeSteps(int num);
// buffer for reading timestep from the XML file the length is of
// NumberOfTimeSteps and therefore is always long enough
int *TimeSteps;
// Store the range of time steps
int TimeStepRange[2];
// Now we need to save what was the last time read for each kind of
// data to avoid rereading it that is to say we need a var for
// e.g. PointData/CellData/Points/Cells...
// See SubClass for details with member vars like PointsTimeStep/PointsOffset
// Helper function useful to know if a timestep is found in an array of timestep
static int IsTimeStepInArray(int timestep, int* timesteps, int length);
vtkDataObject* GetCurrentOutput();
vtkInformation* GetCurrentOutputInformation();
private:
// The stream used to read the input if it is in a file.
ifstream* FileStream;
int TimeStepWasReadOnce;
int FileMajorVersion;
int FileMinorVersion;
vtkDataObject* CurrentOutput;
vtkInformation* CurrentOutputInformation;
private:
vtkXMLReader(const vtkXMLReader&); // Not implemented.
void operator=(const vtkXMLReader&); // Not implemented.
};
#endif
|