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