VTK  9.2.6
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 =========================================================================*/
33 #ifndef vtkXMLWriter_h
34 #define vtkXMLWriter_h
35 
36 #include "vtkIOXMLModule.h" // For export macro
37 #include "vtkXMLWriterBase.h"
38 
39 #include <sstream> // For ostringstream ivar
40 
41 class vtkAbstractArray;
42 class vtkArrayIterator;
43 
44 template <class T>
46 
47 class vtkCellData;
48 class vtkDataArray;
49 class vtkDataCompressor;
50 class vtkDataSet;
52 class vtkFieldData;
53 class vtkOutputStream;
54 class vtkPointData;
55 class vtkPoints;
56 class vtkFieldData;
57 class vtkXMLDataHeader;
58 
59 class vtkStdString;
60 class OffsetsManager; // one per piece/per time
61 class OffsetsManagerGroup; // array of OffsetsManager
62 class OffsetsManagerArray; // array of OffsetsManagerGroup
63 
64 class VTKIOXML_EXPORT vtkXMLWriter : public vtkXMLWriterBase
65 {
66 public:
68  void PrintSelf(ostream& os, vtkIndent indent) override;
69 
71 
76  void SetInputData(vtkDataObject*);
77  void SetInputData(int, vtkDataObject*);
78  vtkDataObject* GetInput(int port);
79  vtkDataObject* GetInput() { return this->GetInput(0); }
81 
82  // See the vtkAlgorithm for a description of what these do
84  vtkInformationVector* outputVector) override;
85 
87 
90  vtkGetMacro(NumberOfTimeSteps, int);
91  vtkSetMacro(NumberOfTimeSteps, int);
93 
95 
98  void Start();
99  void Stop();
100  void WriteNextTime(double time);
102 
103 protected:
104  vtkXMLWriter();
105  ~vtkXMLWriter() override;
106 
107  virtual int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
108  vtkInformationVector* outputVector);
109  virtual int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
110  vtkInformationVector* outputVector);
111 
112  // The output stream to which the XML is written.
113  ostream* Stream;
114 
115  // The stream position at which appended data starts.
116  vtkTypeInt64 AppendedDataPosition;
117 
118  // appended data offsets for field data
119  OffsetsManagerGroup* FieldDataOM; // one per array
120 
121  // We need a 32 bit signed integer type to which vtkIdType will be
122  // converted if Int32 is specified for the IdType parameter to this
123  // writer.
124 #if VTK_SIZEOF_SHORT == 4
125  typedef short Int32IdType;
126 #elif VTK_SIZEOF_INT == 4
127  typedef int Int32IdType;
128 #elif VTK_SIZEOF_LONG == 4
129  typedef long Int32IdType;
130 #else
131 #error "No native data type can represent a signed 32-bit integer."
132 #endif
133 
134  // Buffer for vtkIdType conversion.
135  Int32IdType* Int32IdTypeBuffer;
136 
137  // The byte swapping buffer.
138  unsigned char* ByteSwapBuffer;
139 
140  // Compression information.
144 
145  // The output stream used to write binary and appended data. May
146  // transparently encode the data.
148 
149  // Allow subclasses to set the data stream.
150  virtual void SetDataStream(vtkOutputStream*);
151  vtkGetObjectMacro(DataStream, vtkOutputStream);
152 
153  // Method to drive most of actual writing.
154  virtual int WriteInternal();
155 
156  // Method defined by subclasses to write data. Return 1 for
157  // success, 0 for failure.
158  virtual int WriteData() { return 1; }
159 
160  // Method defined by subclasses to specify the data set's type name.
161  virtual const char* GetDataSetName() = 0;
162 
163  // Utility methods for subclasses.
164  vtkDataSet* GetInputAsDataSet();
165  virtual int StartFile();
166  virtual void WriteFileAttributes();
167  virtual int EndFile();
168  void DeleteAFile();
169  void DeleteAFile(const char* name);
170 
171  virtual int WritePrimaryElement(ostream& os, vtkIndent indent);
172  virtual void WritePrimaryElementAttributes(ostream& os, vtkIndent indent);
173  void StartAppendedData();
174  void EndAppendedData();
175 
176  // Write enough space to go back and write the given attribute with
177  // at most "length" characters in the value. Returns the stream
178  // position at which attribute should be later written. The default
179  // length of 20 is enough for a 64-bit integer written in decimal or
180  // a double-precision floating point value written to 13 digits of
181  // precision (the other 7 come from a minus sign, decimal place, and
182  // a big exponent like "e+300").
183  vtkTypeInt64 ReserveAttributeSpace(const char* attr, size_t length = 20);
184 
185  vtkTypeInt64 GetAppendedDataOffset();
186  void WriteAppendedDataOffset(
187  vtkTypeInt64 streamPos, vtkTypeInt64& lastoffset, const char* attr = nullptr);
188  void ForwardAppendedDataOffset(
189  vtkTypeInt64 streamPos, vtkTypeInt64 offset, const char* attr = nullptr);
190  void ForwardAppendedDataDouble(vtkTypeInt64 streamPos, double value, const char* attr);
191 
192  int WriteScalarAttribute(const char* name, int data);
193  int WriteScalarAttribute(const char* name, float data);
194  int WriteScalarAttribute(const char* name, double data);
195 #ifdef VTK_USE_64BIT_IDS
196  int WriteScalarAttribute(const char* name, vtkIdType data);
197 #endif
198 
199  int WriteVectorAttribute(const char* name, int length, int* data);
200  int WriteVectorAttribute(const char* name, int length, float* data);
201  int WriteVectorAttribute(const char* name, int length, double* data);
202 #ifdef VTK_USE_64BIT_IDS
203  int WriteVectorAttribute(const char* name, int length, vtkIdType* data);
204 #endif
205 
206  int WriteDataModeAttribute(const char* name);
207  int WriteWordTypeAttribute(const char* name, int dataType);
208  int WriteStringAttribute(const char* name, const char* value);
209 
210  // Returns true if any keys were written.
211  bool WriteInformation(vtkInformation* info, vtkIndent indent);
212 
213  void WriteArrayHeader(vtkAbstractArray* a, vtkIndent indent, const char* alternateName,
214  int writeNumTuples, int timestep);
215  virtual void WriteArrayFooter(
216  ostream& os, vtkIndent indent, vtkAbstractArray* a, int shortFormat);
217  virtual void WriteArrayInline(vtkAbstractArray* a, vtkIndent indent,
218  const char* alternateName = nullptr, int writeNumTuples = 0);
219  virtual void WriteInlineData(vtkAbstractArray* a, vtkIndent indent);
220 
221  void WriteArrayAppended(vtkAbstractArray* a, vtkIndent indent, OffsetsManager& offs,
222  const char* alternateName = nullptr, int writeNumTuples = 0, int timestep = 0);
223  int WriteAsciiData(vtkAbstractArray* a, vtkIndent indent);
224  int WriteBinaryData(vtkAbstractArray* a);
225  int WriteBinaryDataInternal(vtkAbstractArray* a);
226  void WriteArrayAppendedData(vtkAbstractArray* a, vtkTypeInt64 pos, vtkTypeInt64& lastoffset);
227 
228  // Methods for writing points, point data, and cell data.
229  void WriteFieldData(vtkIndent indent);
230  void WriteFieldDataInline(vtkFieldData* fd, vtkIndent indent);
231  void WritePointDataInline(vtkPointData* pd, vtkIndent indent);
232  void WriteCellDataInline(vtkCellData* cd, vtkIndent indent);
233  void WriteFieldDataAppended(vtkFieldData* fd, vtkIndent indent, OffsetsManagerGroup* fdManager);
234  void WriteFieldDataAppendedData(vtkFieldData* fd, int timestep, OffsetsManagerGroup* fdManager);
235  void WritePointDataAppended(vtkPointData* pd, vtkIndent indent, OffsetsManagerGroup* pdManager);
236  void WritePointDataAppendedData(vtkPointData* pd, int timestep, OffsetsManagerGroup* pdManager);
237  void WriteCellDataAppended(vtkCellData* cd, vtkIndent indent, OffsetsManagerGroup* cdManager);
238  void WriteCellDataAppendedData(vtkCellData* cd, int timestep, OffsetsManagerGroup* cdManager);
239  void WriteAttributeIndices(vtkDataSetAttributes* dsa, char** names);
240  void WritePointsAppended(vtkPoints* points, vtkIndent indent, OffsetsManager* manager);
241  void WritePointsAppendedData(vtkPoints* points, int timestep, OffsetsManager* pdManager);
242  void WritePointsInline(vtkPoints* points, vtkIndent indent);
243  void WriteCoordinatesInline(
244  vtkDataArray* xc, vtkDataArray* yc, vtkDataArray* zc, vtkIndent indent);
245  void WriteCoordinatesAppended(vtkDataArray* xc, vtkDataArray* yc, vtkDataArray* zc,
246  vtkIndent indent, OffsetsManagerGroup* coordManager);
247  void WriteCoordinatesAppendedData(vtkDataArray* xc, vtkDataArray* yc, vtkDataArray* zc,
248  int timestep, OffsetsManagerGroup* coordManager);
249  void WritePPointData(vtkPointData* pd, vtkIndent indent);
250  void WritePCellData(vtkCellData* cd, vtkIndent indent);
251  void WritePPoints(vtkPoints* points, vtkIndent indent);
252  void WritePArray(vtkAbstractArray* a, vtkIndent indent, const char* alternateName = nullptr);
253  void WritePCoordinates(vtkDataArray* xc, vtkDataArray* yc, vtkDataArray* zc, vtkIndent indent);
254 
255  // Internal utility methods.
256  int WriteBinaryDataBlock(unsigned char* in_data, size_t numWords, int wordType);
257  void PerformByteSwap(void* data, size_t numWords, size_t wordSize);
258  int CreateCompressionHeader(size_t size);
259  int WriteCompressionBlock(unsigned char* data, size_t size);
260  int WriteCompressionHeader();
261  size_t GetWordTypeSize(int dataType);
262  const char* GetWordTypeName(int dataType);
263  size_t GetOutputWordTypeSize(int dataType);
264 
265  char** CreateStringArray(int numStrings);
266  void DestroyStringArray(int numStrings, char** strings);
267 
268  // The current range over which progress is moving. This allows for
269  // incrementally fine-tuned progress updates.
270  virtual void GetProgressRange(float range[2]);
271  virtual void SetProgressRange(const float range[2], int curStep, int numSteps);
272  virtual void SetProgressRange(const float range[2], int curStep, const float* fractions);
273  virtual void SetProgressPartial(float fraction);
274  virtual void UpdateProgressDiscrete(float progress);
275  float ProgressRange[2];
276 
277  // This shallows copy input field data to the passed field data and
278  // then adds any additional field arrays. For example, TimeValue.
279  void UpdateFieldData(vtkFieldData*);
280 
281  ostream* OutFile;
282  std::ostringstream* OutStringStream;
283 
284  int OpenStream();
285  int OpenFile();
286  int OpenString();
287  void CloseStream();
288  void CloseFile();
289  void CloseString();
290 
291  // The timestep currently being written
294 
295  // Dummy boolean var to start/stop the continue executing:
296  // when using the Start/Stop/WriteNextTime API
297  int UserContinueExecuting; // can only be -1 = invalid, 0 = stop, 1 = start
298 
299  vtkTypeInt64* NumberOfTimeValues; // one per piece / per timestep
300 
301  friend class vtkXMLWriterHelper;
302 
303 private:
304  vtkXMLWriter(const vtkXMLWriter&) = delete;
305  void operator=(const vtkXMLWriter&) = delete;
306 };
307 
308 #endif
vtkTypeInt64 * NumberOfTimeValues
Definition: vtkXMLWriter.h:299
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:38
int NumberOfTimeSteps
Definition: vtkXMLWriter.h:293
Abstract interface for data compression classes.
represent and manipulate point attribute data
Definition: vtkPointData.h:41
vtkDataObject * GetInput()
Assign a data object as input.
Definition: vtkXMLWriter.h:79
Store vtkAlgorithm input/output information.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
Abstract superclass for all arrays.
represent and manipulate cell attribute data
Definition: vtkCellData.h:41
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
ostream * OutFile
Definition: vtkXMLWriter.h:281
Helper class due to PIMPL excess.
int vtkIdType
Definition: vtkType.h:332
Implementation template for a array iterator.
vtkOutputStream * DataStream
Definition: vtkXMLWriter.h:147
virtual int WriteData()
Definition: vtkXMLWriter.h:158
int vtkTypeBool
Definition: vtkABI.h:69
virtual vtkTypeBool ProcessRequest(vtkInformation *request, vtkInformationVector **inInfo, vtkInformationVector *outInfo)
Upstream/Downstream requests form the generalized interface through which executives invoke a algorit...
vtkTypeInt64 AppendedDataPosition
Definition: vtkXMLWriter.h:116
Superclass for VTK's XML file writers.
Definition: vtkXMLWriter.h:64
a simple class to control print indentation
Definition: vtkIndent.h:39
Abstract base class for VTK-XML writers.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
std::ostringstream * OutStringStream
Definition: vtkXMLWriter.h:282
size_t CompressionBlockNumber
Definition: vtkXMLWriter.h:141
Abstract superclass to iterate over elements in an vtkAbstractArray.
represent and manipulate attribute data in a dataset
vtkTypeInt64 CompressionHeaderPosition
Definition: vtkXMLWriter.h:143
int CurrentTimeIndex
Definition: vtkXMLWriter.h:292
Wraps a binary output stream with a VTK interface.
Store zero or more vtkInformation instances.
ostream * Stream
Definition: vtkXMLWriter.h:113
unsigned char * ByteSwapBuffer
Definition: vtkXMLWriter.h:138
general representation of visualization data
Definition: vtkDataObject.h:65
represent and manipulate 3D points
Definition: vtkPoints.h:39
vtkXMLDataHeader * CompressionHeader
Definition: vtkXMLWriter.h:142
int UserContinueExecuting
Definition: vtkXMLWriter.h:297
OffsetsManagerGroup * FieldDataOM
Definition: vtkXMLWriter.h:119
represent and manipulate fields of data
Definition: vtkFieldData.h:62
Int32IdType * Int32IdTypeBuffer
Definition: vtkXMLWriter.h:135