Main Page | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

vtkXMLWriter.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    $RCSfile: vtkXMLWriter.h,v $
00005   Language:  C++
00006 
00007   Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen 
00008   All rights reserved.
00009   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
00010 
00011      This software is distributed WITHOUT ANY WARRANTY; without even 
00012      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00013      PURPOSE.  See the above copyright notice for more information.
00014 
00015 =========================================================================*/
00028 #ifndef __vtkXMLWriter_h
00029 #define __vtkXMLWriter_h
00030 
00031 #include "vtkProcessObject.h"
00032 
00033 class vtkCellData;
00034 class vtkDataArray;
00035 class vtkDataCompressor;
00036 class vtkDataSet;
00037 class vtkDataSetAttributes;
00038 class vtkOutputStream;
00039 class vtkPointData;
00040 class vtkPoints;
00041 
00042 class VTK_IO_EXPORT vtkXMLWriter : public vtkProcessObject
00043 {
00044 public:
00045   vtkTypeRevisionMacro(vtkXMLWriter,vtkProcessObject);
00046   void PrintSelf(ostream& os, vtkIndent indent);
00047   
00048   //BTX
00050 
00051   enum { BigEndian, LittleEndian };
00052   //ETX
00054   
00055   //BTX
00057 
00060   enum { Ascii, Binary, Appended };
00061   //ETX
00063   
00064   //BTX
00066 
00069   enum { Int32=32, Int64=64 };
00070   //ETX
00072   
00074 
00076   vtkSetMacro(ByteOrder, int);
00077   vtkGetMacro(ByteOrder, int);
00078   void SetByteOrderToBigEndian();
00079   void SetByteOrderToLittleEndian();
00081   
00083 
00085   virtual void SetIdType(int);
00086   vtkGetMacro(IdType, int);
00087   void SetIdTypeToInt32();
00088   void SetIdTypeToInt64();
00090   
00092 
00093   vtkSetStringMacro(FileName);
00094   vtkGetStringMacro(FileName);
00096   
00098 
00100   virtual void SetCompressor(vtkDataCompressor*);
00101   vtkGetObjectMacro(Compressor, vtkDataCompressor);
00103   
00105 
00109   virtual void SetBlockSize(unsigned int blockSize);
00110   vtkGetMacro(BlockSize, unsigned int);
00112   
00114 
00117   vtkSetMacro(DataMode, int);
00118   vtkGetMacro(DataMode, int);
00119   void SetDataModeToAscii();
00120   void SetDataModeToBinary();
00121   void SetDataModeToAppended();
00123   
00125 
00130   vtkSetMacro(EncodeAppendedData, int);
00131   vtkGetMacro(EncodeAppendedData, int);
00132   vtkBooleanMacro(EncodeAppendedData, int);
00134   
00136   virtual const char* GetDefaultFileExtension()=0;
00137   
00139   virtual int Write();
00140   
00141 protected:
00142   vtkXMLWriter();
00143   ~vtkXMLWriter();
00144   
00145   // The name of the output file.
00146   char* FileName;
00147   
00148   // The output stream to which the XML is written.
00149   ostream* Stream;  
00150   
00151   // The output byte order.
00152   int ByteOrder;
00153   
00154   // The output vtkIdType.
00155   int IdType;
00156   
00157   // The form of binary data to write.  Used by subclasses to choose
00158   // how to write data.
00159   int DataMode;
00160   
00161   // Whether to base64-encode the appended data section.
00162   int EncodeAppendedData;
00163   
00164   // The stream position at which appended data starts.
00165   unsigned long AppendedDataPosition;
00166 
00167   //BTX
00168   // We need a 32 bit unsigned integer type for platform-independent
00169   // binary headers.  Note that this is duplicated in
00170   // vtkXMLDataParser.h.
00171 #if VTK_SIZEOF_SHORT == 4
00172   typedef unsigned short HeaderType;
00173 #elif VTK_SIZEOF_INT == 4
00174   typedef unsigned int HeaderType;
00175 #elif VTK_SIZEOF_LONG == 4
00176   typedef unsigned long HeaderType;
00177 #else
00178 # error "No native data type can represent an unsigned 32-bit integer."
00179 #endif
00180   //ETX
00181 
00182   //BTX
00183   // We need a 32 bit signed integer type to which vtkIdType will be
00184   // converted if Int32 is specified for the IdType parameter to this
00185   // writer.
00186 # if VTK_SIZEOF_SHORT == 4
00187   typedef short Int32IdType;
00188 # elif VTK_SIZEOF_INT == 4
00189   typedef int Int32IdType;
00190 # elif VTK_SIZEOF_LONG == 4
00191   typedef long Int32IdType;
00192 # else
00193 #  error "No native data type can represent a signed 32-bit integer."
00194 # endif  
00195   //ETX
00196   
00197   // Buffer for vtkIdType conversion.
00198   Int32IdType* Int32IdTypeBuffer;
00199   
00200   // The byte swapping buffer.
00201   unsigned char* ByteSwapBuffer;
00202   
00203   // Compression information.
00204   vtkDataCompressor* Compressor;
00205   unsigned int   BlockSize;  
00206   unsigned long  CompressionBlockNumber;
00207   HeaderType*    CompressionHeader;
00208   unsigned int   CompressionHeaderLength;
00209   unsigned long  CompressionHeaderPosition;
00210   
00211   // The output stream used to write binary and appended data.  May
00212   // transparently encode the data.
00213   vtkOutputStream* DataStream;
00214   
00215   // Allow subclasses to set the data stream.
00216   virtual void SetDataStream(vtkOutputStream*);
00217   vtkGetObjectMacro(DataStream, vtkOutputStream);  
00218   
00219   // Method defined by subclasses to write data.  Return 1 for
00220   // success, 0 for failure.
00221   virtual int WriteData()=0;
00222   
00223   // Method defined by subclasses to specify the data set's type name.
00224   virtual const char* GetDataSetName()=0;
00225   
00226   // Methods to define the file's major and minor version numbers.
00227   virtual int GetDataSetMajorVersion();
00228   virtual int GetDataSetMinorVersion();
00229   
00230   // Utility methods for subclasses.
00231   vtkDataSet* GetInputAsDataSet();  
00232   void StartFile();
00233   virtual void WriteFileAttributes();
00234   void EndFile();
00235   void StartAppendedData();
00236   void EndAppendedData();
00237   unsigned long ReserveAttributeSpace(const char* attr=0);
00238   unsigned long GetAppendedDataOffset();
00239   unsigned long WriteAppendedDataOffset(unsigned long streamPos,
00240                                         const char* attr=0);
00241   int WriteBinaryData(void* data, int numWords, int wordType);
00242   
00243   int WriteBinaryData(char* data)
00244     { return this->WriteBinaryData(data, static_cast<int>(strlen(data)),
00245                                    VTK_CHAR); }
00246   int WriteBinaryData(char* data, int numWords)
00247     { return this->WriteBinaryData(data, numWords, VTK_CHAR); }
00248   int WriteBinaryData(unsigned char* data, int numWords)
00249     { return this->WriteBinaryData(data, numWords, VTK_UNSIGNED_CHAR); }
00250   int WriteBinaryData(short* data, int numWords)
00251     { return this->WriteBinaryData(data, numWords, VTK_SHORT); }
00252   int WriteBinaryData(unsigned short* data, int numWords)
00253     { return this->WriteBinaryData(data, numWords, VTK_UNSIGNED_SHORT); }
00254   int WriteBinaryData(int* data, int numWords)
00255     { return this->WriteBinaryData(data, numWords, VTK_INT); }
00256   int WriteBinaryData(unsigned int* data, int numWords)
00257     { return this->WriteBinaryData(data, numWords, VTK_UNSIGNED_INT); }
00258   
00259   int WriteAsciiData(void* data, int numWords, int wordType, vtkIndent indent);
00260   
00261   int WriteAsciiData(char* data, vtkIndent indent)
00262     { return this->WriteAsciiData(data, static_cast<int>(strlen(data)),
00263                                   VTK_CHAR, indent); }
00264   int WriteAsciiData(char* data, int numWords, vtkIndent indent)
00265     { return this->WriteAsciiData(data, numWords, VTK_CHAR, indent); }
00266   int WriteAsciiData(unsigned char* data, int numWords, vtkIndent indent)
00267     { return this->WriteAsciiData(data, numWords, VTK_UNSIGNED_CHAR, indent); }
00268   int WriteAsciiData(short* data, int numWords, vtkIndent indent)
00269     { return this->WriteAsciiData(data, numWords, VTK_SHORT, indent); }
00270   int WriteAsciiData(unsigned short* data, int numWords, vtkIndent indent)
00271     { return this->WriteAsciiData(data, numWords, VTK_UNSIGNED_SHORT, indent); }
00272   int WriteAsciiData(int* data, int numWords, vtkIndent indent)
00273     { return this->WriteAsciiData(data, numWords, VTK_INT, indent); }
00274   int WriteAsciiData(unsigned int* data, int numWords, vtkIndent indent)
00275     { return this->WriteAsciiData(data, numWords, VTK_UNSIGNED_INT, indent); }
00276   
00277   int WriteScalarAttribute(const char* name, int data);
00278   int WriteScalarAttribute(const char* name, float data);
00279 #ifdef VTK_ID_TYPE_IS_NOT_BASIC_TYPE
00280   int WriteScalarAttribute(const char* name, vtkIdType data);
00281 #endif
00282   
00283   int WriteVectorAttribute(const char* name, int length, int* data);
00284   int WriteVectorAttribute(const char* name, int length, float* data);
00285 #ifdef VTK_ID_TYPE_IS_NOT_BASIC_TYPE
00286   int WriteVectorAttribute(const char* name, int length, vtkIdType* data);
00287 #endif
00288   
00289   int WriteDataModeAttribute(const char* name);
00290   int WriteWordTypeAttribute(const char* name, int dataType);
00291   int WriteStringAttribute(const char* name, const char* value);
00292   
00293   unsigned long WriteDataArrayAppended(vtkDataArray* a, vtkIndent indent,
00294                                        const char* alternateName=0);
00295   void WriteDataArrayAppendedData(vtkDataArray* a, unsigned long pos);
00296   void WriteDataArrayInline(vtkDataArray* a, vtkIndent indent,
00297                             const char* alternateName=0);
00298   void WriteInlineData(void* data, int numWords, int wordType,
00299                        vtkIndent indent);
00300   
00301   // Methods for writing points, point data, and cell data.
00302   void WritePointDataInline(vtkPointData* pd, vtkIndent indent);
00303   void WriteCellDataInline(vtkCellData* cd, vtkIndent indent);
00304   unsigned long* WritePointDataAppended(vtkPointData* pd, vtkIndent indent);
00305   void WritePointDataAppendedData(vtkPointData* pd, unsigned long* pdPositions);
00306   unsigned long* WriteCellDataAppended(vtkCellData* cd, vtkIndent indent);
00307   void WriteCellDataAppendedData(vtkCellData* cd, unsigned long* cdPositions);
00308   void WriteAttributeIndices(vtkDataSetAttributes* dsa, char** names);
00309   unsigned long WritePointsAppended(vtkPoints* points, vtkIndent indent);
00310   void WritePointsAppendedData(vtkPoints* points, unsigned long pointsPosition);
00311   void WritePointsInline(vtkPoints* points, vtkIndent indent);
00312   void WriteCoordinatesInline(vtkDataArray* xc, vtkDataArray* yc,
00313                               vtkDataArray* zc, vtkIndent indent);
00314   unsigned long* WriteCoordinatesAppended(vtkDataArray* xc, vtkDataArray* yc,
00315                                           vtkDataArray* zc, vtkIndent indent);
00316   void WriteCoordinatesAppendedData(vtkDataArray* xc, vtkDataArray* yc,
00317                                     vtkDataArray* zc,
00318                                     unsigned long* cPositions);
00319   virtual vtkDataArray* CreateArrayForPoints(vtkDataArray* inArray);
00320   virtual vtkDataArray* CreateArrayForCells(vtkDataArray* inArray);
00321   virtual vtkDataArray* CreateExactCoordinates(vtkDataArray* inArray, int xyz);
00322   void WritePPointData(vtkPointData* pd, vtkIndent indent);
00323   void WritePCellData(vtkCellData* cd, vtkIndent indent);
00324   void WritePPoints(vtkPoints* points, vtkIndent indent);
00325   void WritePDataArray(vtkDataArray* a, vtkIndent indent,
00326                        const char* alternateName=0);
00327   void WritePCoordinates(vtkDataArray* xc, vtkDataArray* yc,
00328                          vtkDataArray* zc, vtkIndent indent);
00329   
00330   // Internal utility methods.
00331   int WriteBinaryDataInternal(void* data, int numWords, int wordType);
00332   int WriteBinaryDataBlock(unsigned char* in_data, int numWords, int wordType);
00333   void PerformByteSwap(void* data, int numWords, int wordSize);
00334   int CreateCompressionHeader(unsigned long size);
00335   int WriteCompressionBlock(unsigned char* data, unsigned long size);
00336   int WriteCompressionHeader();
00337   unsigned long GetWordTypeSize(int dataType);
00338   const char* GetWordTypeName(int dataType);
00339   unsigned long GetOutputWordTypeSize(int dataType);
00340   
00341   char** CreateStringArray(int numStrings);
00342   void DestroyStringArray(int numStrings, char** strings);
00343   virtual int IsSafeToWrite();
00344   
00345 private:
00346   vtkXMLWriter(const vtkXMLWriter&);  // Not implemented.
00347   void operator=(const vtkXMLWriter&);  // Not implemented.
00348 };
00349 
00350 #endif