3 This file is part of DIG Library.
4 DIG Library is a free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published
6 by the Free Software Foundation; either version 2 of the License,
7 or (at your option) any later version.
8 DIG Library is distributed in the hope that it will be useful, but
9 WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 General Public License for more details.
12 You should have received a copy of the GNU General Public License
13 along with Foobar; if not, write to the Free Software Foundation,
14 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 // DIGFile.cpp,v 1.20 2007/06/14 17:10:50 swr Exp
20 //defines added to enable large file support
21 //jklukowska, 06/07/2007
22 #ifndef _LARGEFILE_SOURCE
23 #define _LARGEFILE_SOURCE /* enable large file support */
25 #ifndef _FILE_OFFSET_BITS
26 #define _FILE_OFFSET_BITS 64 /* enable large file support */
29 // bug 226 - needed to compile this file on cygwin - swr - 6/14/07
30 #undef __STRICT_ANSI__
38 #include <xercesc/framework/StdOutFormatTarget.hpp>
39 #include <xercesc/framework/LocalFileFormatTarget.hpp>
40 #include <xercesc/framework/MemBufFormatTarget.hpp>
42 //#include <xercesc/util/XMLDouble.hpp>
45 //#include "DIGFile.h"
46 #include <DIGFile/DIGFile.h>
48 #define DIGFILE_DEBUG_LEVEL 0
51 const char* DIGEndianStr[DIGEndianSize] = {
56 const char* DIGValueTypeStr[DIGValueTypeSize] = {
61 const char* DIGDataTypeStr[DIGDataTypeSize] = {
73 const char* DIGDataFormatStr[DIGDataFormatSize] = {
78 const char* DIGGridStr[DIGGridSize] = {
90 const char* DIGBasisStr[DIGBasisSize] = {
95 const char* DIGUnitStr[DIGUnitSize] = {
106 static char DIGEmptyStr[1] = "";
108 bool DIGFile::XMLStringsInitialized = false;
110 const XMLCh* DIGFile::RootXMLStr;
112 const XMLCh* DIGFile::MainHeaderXMLStr;
114 const XMLCh* DIGFile::TitleXMLStr;
115 const XMLCh* DIGFile::TypeXMLStr;
116 const XMLCh* DIGFile::ChannelsXMLStr;
117 const XMLCh* DIGFile::NumberOfArraysXMLStr;
118 const XMLCh* DIGFile::NumberOfArraySetsXMLStr;
119 const XMLCh* DIGFile::EndianXMLStr;
120 const XMLCh* DIGFile::ValueTypeXMLStr;
121 const XMLCh* DIGFile::DataTypeXMLStr;
122 const XMLCh* DIGFile::DataFormatXMLStr;
123 const XMLCh* DIGFile::GridTypeXMLStr;
124 const XMLCh* DIGFile::BasisFunctionXMLStr;
125 const XMLCh* DIGFile::UnitXMLStr;
126 const XMLCh* DIGFile::OtherUnitXMLStr;
127 const XMLCh* DIGFile::CommentsXMLStr;
128 const XMLCh* DIGFile::DimensionsXMLStr;
130 const XMLCh* DIGFile::DimmensionXXMLStr;
131 const XMLCh* DIGFile::DimmensionYXMLStr;
132 const XMLCh* DIGFile::DimmensionZXMLStr;
134 const XMLCh* DIGFile::SamplingRateXXMLStr;
135 const XMLCh* DIGFile::SamplingRateYXMLStr;
136 const XMLCh* DIGFile::SamplingRateZXMLStr;
138 const XMLCh* DIGFile::ArraySetHeaderXMLStr;
140 //const XMLCh* DIGFile::TypeXMLStr;
141 //const XMLCh* DIGFile::TitleXMLStr;
142 const XMLCh* DIGFile::ParametersXMLStr;
144 const XMLCh* DIGFile::ArrayHeaderXMLStr;
145 const XMLCh* DIGFile::EnumerationNumberXMLStr;
148 class DOMPrintErrorHandler : public DOMErrorHandler
152 DOMPrintErrorHandler(){};
153 ~DOMPrintErrorHandler(){};
155 /** @name The error handler interface */
156 bool handleError(const DOMError& domError);
157 void resetErrors(){};
160 /* Unimplemented constructors and operators */
161 DOMPrintErrorHandler(const DOMErrorHandler&);
162 void operator=(const DOMErrorHandler&);
166 bool DOMPrintErrorHandler::handleError(const DOMError &domError)
168 // Display whatever error message passed from the serializer
169 char *msg = XMLString::transcode(domError.getMessage());
170 std::cout<<msg<<std::endl;
173 // Instructs the serializer to continue serialization if possible.
180 #if DIGFILE_DEBUG_LEVEL > 2
\r
181 fprintf(stderr, "DIGFile::DIGFile\n");
\r
184 MainHeaderWritten = false;
185 ArraySetOpen = false;
194 // ??????????????????????????
197 #if DIGFILE_DEBUG_LEVEL > 1
\r
198 printf("Initializing XML parser\n");
\r
202 XMLPlatformUtils::Initialize();
204 catch(const XMLException &toCatch) {
205 std::cerr << "Error during Xerces-c Initialization.\n"
206 << " Exception message:"
207 << StrX(toCatch.getMessage()) << std::endl;
211 if(!XMLStringsInitialized) {
213 RootXMLStr = XMLString::transcode("DIG_DATA");
215 MainHeaderXMLStr = XMLString::transcode("main_header");
217 TitleXMLStr = XMLString::transcode("title");
218 TypeXMLStr = XMLString::transcode("type");
219 ChannelsXMLStr = XMLString::transcode("channels");
220 NumberOfArraysXMLStr = XMLString::transcode("number_of_arrays");
221 NumberOfArraySetsXMLStr = XMLString::transcode("number_of_array_sets");
222 EndianXMLStr = XMLString::transcode("endian");
223 ValueTypeXMLStr = XMLString::transcode("value_type");
224 DataTypeXMLStr = XMLString::transcode("data_type");
225 DataFormatXMLStr = XMLString::transcode("data_format");
226 GridTypeXMLStr = XMLString::transcode("grid_type");
227 BasisFunctionXMLStr = XMLString::transcode("basis_function");
228 UnitXMLStr = XMLString::transcode("unit");
229 OtherUnitXMLStr = XMLString::transcode("other_unit");
230 CommentsXMLStr = XMLString::transcode("comments");
231 DimensionsXMLStr = XMLString::transcode("dimensions");
233 DimmensionXXMLStr = XMLString::transcode("x");
234 DimmensionYXMLStr = XMLString::transcode("y");
235 DimmensionZXMLStr = XMLString::transcode("z");
237 SamplingRateXXMLStr = XMLString::transcode("sampling_rate_x");
238 SamplingRateYXMLStr = XMLString::transcode("sampling_rate_y");
239 SamplingRateZXMLStr = XMLString::transcode("sampling_rate_z");
241 ArraySetHeaderXMLStr = XMLString::transcode("array_set_header");
243 // TypeXMLStr = XMLString::transcode("type");
244 // TitleXMLStr = XMLString::transcode("title");
245 ParametersXMLStr = XMLString::transcode("parameters");
247 ArrayHeaderXMLStr = XMLString::transcode("array_header");
248 EnumerationNumberXMLStr = XMLString::transcode("enumeration_number");
250 XMLStringsInitialized = true;
254 int DIGFile::FindSrting(char* String, FILE* File)
256 #if DIGFILE_DEBUG_LEVEL > 2
\r
257 fprintf(stderr, "DIGFile::FindSrting\n");
\r
264 // get legth of the string
265 int len = strlen(String);
267 // create input buffer
268 char* Buffer = new char[len];
273 // find match for first character in the string
274 while((ch = getc(File)) != String[0] && (ch != EOF)) {
279 return -1; // not found
282 // put first file character into the buffer
288 // fill Buffer with file characters
289 for(i = count; i < len; i++) {
290 if((ch = getc(File)) == EOF) {
294 tail = (tail + 1) % len;
302 for(i = 1; i < len; i++) {
304 ptr = (ptr + 1) % len;
306 if(Buffer[ptr] != String[i]) {
307 break; // found first difference
311 if(i == len) { // full match
315 // move head to the next match for first character
318 head = (head + 1) % len;
321 if(Buffer[head] == String[0]) {
322 break; // found match for first character in the string
332 int DIGFile::GetXMLHeader(char** XMLBuff)
334 #if DIGFILE_DEBUG_LEVEL > 2
\r
335 fprintf(stderr, "DIGFile::GetXMLHeader\n");
\r
338 static char TerminationString[] = "</DIG_DATA>";
340 #if DIGFILE_DEBUG_LEVEL > 1
\r
341 printf("Searching for XML termnation\n");
\r
344 // search for end of XML
345 if((XMLHeaderLength = FindSrting(TerminationString, File)) == -1) {
\r
346 #if DIGFILE_DEBUG_LEVEL > 0
\r
347 printf("** Error: missing XML termnation\n");
\r
349 return -1; // error missing XML termnation
352 // add length of termnating string and 1 for the following LF
353 XMLHeaderLength += strlen(TerminationString) + 1;
355 #if DIGFILE_DEBUG_LEVEL > 1
\r
356 printf("Reading XML Header\n");
\r
359 // read XML to memory
360 *XMLBuff = new char[XMLHeaderLength+1];
364 if(fread((void*) *XMLBuff, 1, XMLHeaderLength, File) != (unsigned int) XMLHeaderLength) {
\r
366 #if DIGFILE_DEBUG_LEVEL > 0
\r
367 printf("** Error: reading file\n");
\r
369 return -1; // error reading file
372 (*XMLBuff)[XMLHeaderLength] = 0;
378 // open existing file
380 int DIGFile::Open(const char* FileName)
382 #if DIGFILE_DEBUG_LEVEL > 2
\r
383 fprintf(stderr, "DIGFile::Open\n");
\r
390 #if DIGFILE_DEBUG_LEVEL > 0
\r
391 printf("** Error: DIG File already open\n");
\r
393 return -1; // DIG File already open
396 #if DIGFILE_DEBUG_LEVEL > 1
\r
397 printf("Opening DIG file for reading\n");
\r
400 // try to open DIG File for reading
401 if((File = fopen(FileName, "r+b")) == NULL) {
\r
403 #if DIGFILE_DEBUG_LEVEL > 0
\r
404 printf("** Error: unable to open DIG File\n");
\r
406 return -1; // unable to open DIG File
409 #if DIGFILE_DEBUG_LEVEL > 1
\r
410 printf("Loading XML header\n");
\r
414 if(GetXMLHeader(&XMLBuffer) != 0) {
\r
415 #if DIGFILE_DEBUG_LEVEL > 0
\r
416 printf("** Error: invalid DIG File (missing XML header\n");
\r
418 return -2; // invalid DIG File (missing XML header)
421 #if DIGFILE_DEBUG_LEVEL > 1
\r
422 printf("Parsing XML Header\n");
\r
425 // parse XML and load structures
426 if(ParseXML(XMLBuffer) != 0) {
\r
427 #if DIGFILE_DEBUG_LEVEL > 0
\r
428 printf("** Error: unable to parse XML header\n");
\r
430 return -3; // unable to parse XML header
433 NoOfArrayItems = ComputeArrayNoOfItems();
434 ArrayBufferSize = ComputeArrayBufferSize();
444 const char* pFileName,
448 unsigned int pChannels,
450 DIGValueType pValueType,
451 DIGDataType pDataType,
452 DIGDataFormat pDataFormat,
456 const DIGDimensions* pDimensions,
457 const DIGSampling* pSamplingX,
458 const DIGSampling* pSamplingY,
459 const DIGSampling* pSamplingZ,
460 const char* pComment,
461 const char* pOtherUnit
464 #if DIGFILE_DEBUG_LEVEL > 2
\r
465 fprintf(stderr, "DIGFile::Open\n");
\r
469 #if DIGFILE_DEBUG_LEVEL > 0
\r
470 printf("** Error: DIG File already open\n");
\r
472 return -1; // DIG File already open
475 if(SchemaName.Set(pSchema) != 0) {
\r
476 #if DIGFILE_DEBUG_LEVEL > 0
\r
477 printf("** Error: \n");
\r
482 // open temp file for data
483 TmpDataFile = tmpfile();
485 #if DIGFILE_DEBUG_LEVEL > 1
\r
486 printf("Opening DIG File\n");
\r
489 if((File = fopen(pFileName, "w+b")) == NULL) {
\r
490 #if DIGFILE_DEBUG_LEVEL > 0
\r
491 printf("** Error: unable to open file\n");
\r
493 return -1; // unable to open file
496 MainHeader.Title.Set(pTitle);
497 MainHeader.Type.Set(pType);
498 MainHeader.Channels = pChannels;
499 //MainHeader.number_of_arrays = ;
500 //MainHeader.number_of_sets =;
501 //MainHeader.Endian = pEndian;
502 MainHeader.ValueType = pValueType;
503 MainHeader.DataType = pDataType;
504 MainHeader.DataFormat = pDataFormat;
505 MainHeader.Grid = pGrid;
506 MainHeader.Basis = pBasis;
507 MainHeader.Unit = pUnit;
508 MainHeader.OtherUnit.Set(pOtherUnit);
509 MainHeader.Dimensions.x = pDimensions->x;
510 MainHeader.Dimensions.y = pDimensions->y;
511 MainHeader.Dimensions.z = pDimensions->z;
512 MainHeader.SamplingX.x = pSamplingX->x;
513 MainHeader.SamplingX.y = pSamplingX->y;
514 MainHeader.SamplingX.z = pSamplingX->z;
515 MainHeader.SamplingY.x = pSamplingY->x;
516 MainHeader.SamplingY.y = pSamplingY->y;
517 MainHeader.SamplingY.z = pSamplingY->z;
518 MainHeader.SamplingZ.x = pSamplingZ->x;
519 MainHeader.SamplingZ.y = pSamplingZ->y;
520 MainHeader.SamplingZ.z = pSamplingZ->z;
522 MainHeader.Comment.Set(pComment);
526 NoOfArrayItems = ComputeArrayNoOfItems();
527 ArrayBufferSize = ComputeArrayBufferSize();
532 XMLString::transcode("Core", tempStr, 99);
534 impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
540 int DIGFile::SetComment(const char* pComment)
542 #if DIGFILE_DEBUG_LEVEL > 2
\r
543 fprintf(stderr, "DIGFile::SetComment\n");
\r
546 MainHeader.Comment.Set(pComment);
551 int DIGFile::SetTitle(const char* pTitle)
553 #if DIGFILE_DEBUG_LEVEL > 2
\r
554 fprintf(stderr, "DIGFile::SetTitle\n");
\r
557 MainHeader.Title.Set(pTitle);
562 int DIGFile::GetTitle(const char** pTitle)
564 #if DIGFILE_DEBUG_LEVEL > 2
\r
565 fprintf(stderr, "DIGFile::GetTitle\n");
\r
568 *pTitle = MainHeader.Title.Get();
573 int DIGFile::GetType(const char** pType)
575 #if DIGFILE_DEBUG_LEVEL > 2
\r
576 fprintf(stderr, "DIGFile::GetType\n");
\r
579 *pType = MainHeader.Type.Get();
584 int DIGFile::GetChannels(unsigned int* pChannels)
586 #if DIGFILE_DEBUG_LEVEL > 2
\r
587 fprintf(stderr, "DIGFile::GetChannels\n");
\r
590 *pChannels = MainHeader.Channels;
595 int DIGFile::GetEndian(DIGEndian* pEndian)
597 #if DIGFILE_DEBUG_LEVEL > 2
\r
598 fprintf(stderr, "DIGFile::GetEndian\n");
\r
606 int DIGFile::GetValueType(DIGValueType* pValueType)
608 #if DIGFILE_DEBUG_LEVEL > 2
\r
609 fprintf(stderr, "DIGFile::GetValueType\n");
\r
612 *pValueType = MainHeader.ValueType;
617 int DIGFile::GetDataType(DIGDataType* pDataType)
619 #if DIGFILE_DEBUG_LEVEL > 2
\r
620 fprintf(stderr, "DIGFile::GetDataType\n");
\r
623 *pDataType = MainHeader.DataType;
628 int DIGFile::GetDataFormat(DIGDataFormat* pDataFormat)
630 #if DIGFILE_DEBUG_LEVEL > 2
\r
631 fprintf(stderr, "DIGFile::GetDataFormat\n");
\r
634 *pDataFormat = MainHeader.DataFormat;
639 int DIGFile::GetGrid(DIGGrid* pGrid)
641 #if DIGFILE_DEBUG_LEVEL > 2
\r
642 fprintf(stderr, "DIGFile::GetGrid\n");
\r
645 *pGrid = MainHeader.Grid;
650 int DIGFile::GetBasis(DIGBasis* pBasis)
652 #if DIGFILE_DEBUG_LEVEL > 2
\r
653 fprintf(stderr, "DIGFile::GetBasis\n");
\r
656 *pBasis = MainHeader.Basis;
661 int DIGFile::GetUnit(DIGUnit* pUnit)
663 #if DIGFILE_DEBUG_LEVEL > 2
\r
664 fprintf(stderr, "DIGFile::GetUnit\n");
\r
667 *pUnit = MainHeader.Unit;
672 int DIGFile::GetOtherUnit(const char** pOtherUnit)
674 #if DIGFILE_DEBUG_LEVEL > 2
\r
675 fprintf(stderr, "DIGFile::GetOtherUnit\n");
\r
678 *pOtherUnit = MainHeader.OtherUnit.Get();
683 int DIGFile::GetDimensions(const DIGDimensions** pDimensions)
685 #if DIGFILE_DEBUG_LEVEL > 2
\r
686 fprintf(stderr, "DIGFile::GetDimensions\n");
\r
689 *pDimensions = &(MainHeader.Dimensions);
694 int DIGFile::GetSamplingX(const DIGSampling** pSampling)
696 #if DIGFILE_DEBUG_LEVEL > 2
\r
697 fprintf(stderr, "DIGFile::GetSamplingX\n");
\r
700 *pSampling = &(MainHeader.SamplingX);
705 int DIGFile::GetSamplingY(const DIGSampling** pSampling)
707 #if DIGFILE_DEBUG_LEVEL > 2
\r
708 fprintf(stderr, "DIGFile::GetSamplingY\n");
\r
711 *pSampling = &(MainHeader.SamplingY);
716 int DIGFile::GetSamplingZ(const DIGSampling** pSampling)
718 #if DIGFILE_DEBUG_LEVEL > 2
\r
719 fprintf(stderr, "DIGFile::GetSamplingZ\n");
\r
722 *pSampling = &(MainHeader.SamplingZ);
727 int DIGFile::GetComment(const char** pComment)
729 #if DIGFILE_DEBUG_LEVEL > 2
\r
730 fprintf(stderr, "DIGFile::GetComment\n");
\r
733 *pComment = MainHeader.Comment.Get();
738 unsigned int DIGFile::ComputeArrayNoOfItems()
740 #if DIGFILE_DEBUG_LEVEL > 2
\r
741 fprintf(stderr, "DIGFile::ComputeArrayNoOfItems\n");
\r
744 int Count = MainHeader.Channels *
745 MainHeader.Dimensions.x *
746 MainHeader.Dimensions.y *
747 MainHeader.Dimensions.z;
749 switch(MainHeader.ValueType) {
750 case DIGValueType_REAL:
753 case DIGValueType_COMPLEX:
762 int DIGFile::GetArrayNoOfItems(unsigned int* pArrayNoOfItems)
764 #if DIGFILE_DEBUG_LEVEL > 2
\r
765 fprintf(stderr, "DIGFile::GetArrayNoOfItems\n");
\r
768 *pArrayNoOfItems = NoOfArrayItems;
773 unsigned int DIGFile::ComputeArrayBufferSize()
775 #if DIGFILE_DEBUG_LEVEL > 2
\r
776 fprintf(stderr, "DIGFile::ComputeArrayBufferSize\n");
\r
779 unsigned int Size = NoOfArrayItems;
781 switch(MainHeader.DataType) {
783 case DIGDataType_BOOL:
784 case DIGDataType_UCHAR:
785 case DIGDataType_CHAR:
788 case DIGDataType_USHORT:
789 case DIGDataType_SHORT:
790 return Size * sizeof(short);
792 case DIGDataType_UINT:
793 case DIGDataType_INT:
794 return Size * sizeof(int);
796 case DIGDataType_FLOAT:
797 return Size * sizeof(float);
799 case DIGDataType_DOUBLE:
800 return Size * sizeof(double);
808 int DIGFile::GetArrayBufferSize(unsigned int* pArrayBufferSize)
810 #if DIGFILE_DEBUG_LEVEL > 2
\r
811 fprintf(stderr, "DIGFile::GetArrayBufferSize\n");
\r
814 *pArrayBufferSize = ArrayBufferSize;
819 #define DIG_FILE_BUFFER_SIZE 1024
823 #if DIGFILE_DEBUG_LEVEL > 2
\r
824 fprintf(stderr, "DIGFile::Close\n");
\r
829 // Append data to ouput file (Header is already there)
831 char DataBuffer[DIG_FILE_BUFFER_SIZE];
834 if(WriteXMLHeader() != 0) {
\r
836 #if DIGFILE_DEBUG_LEVEL > 0
\r
837 printf("** Error: unable to write XML header\n");
\r
842 // copy data from temp file to output file
844 while((ReadByteCount = fread(DataBuffer, 1, DIG_FILE_BUFFER_SIZE, TmpDataFile)) > 0) {
845 if(ferror(TmpDataFile) != 0) {
\r
847 #if DIGFILE_DEBUG_LEVEL > 0
\r
848 printf("** Error: error reading temp file\n");
\r
850 return -2; // error reading temp file
853 if(fwrite(DataBuffer, 1, ReadByteCount, File) != (unsigned int) ReadByteCount) {
\r
855 #if DIGFILE_DEBUG_LEVEL > 0
\r
856 printf("** Error: error writing file\n");
\r
858 return -3; // error writing file
867 #if DIGFILE_DEBUG_LEVEL > 0
\r
868 printf("** Error: attempt to close unopen file\n");
\r
870 return -2; // attempt to close unopen file
881 int DIGFile::AppendArraySet(const char* pType, const char* pTitle, const char* pParameters, const char* pComments)
883 #if DIGFILE_DEBUG_LEVEL > 2
\r
884 fprintf(stderr, "DIGFile::AppendArraySet\n");
\r
887 // create new array set header
888 DIGFileArraySetHeader* SetHeader = new DIGFileArraySetHeader(pType, pTitle, pParameters, pComments);
890 // create new array set
891 CurrenArraySet = new ArraySet;
893 // attach array set header
894 CurrenArraySet->ArraySetHeader = SetHeader;
895 CurrenArraySet->FirstArrayOffset = NoOfArrays;
897 // append array set to array set list
898 ArraySets.Append(CurrenArraySet);
900 NoOfSets = ArraySets.getLength();
908 int DIGFile::AppendArray(unsigned int pEnumNo, const char* pComment, const void* pBuffer)
910 #if DIGFILE_DEBUG_LEVEL > 2
\r
911 fprintf(stderr, "DIGFile::AppendArray\n");
\r
914 if(CurrenArraySet == NULL) {
\r
916 #if DIGFILE_DEBUG_LEVEL > 0
\r
917 printf("** Error: no array set selected\n");
\r
919 return -1; // no array set selected
922 DIGFileArrayHeader* ArrayHeader = new DIGFileArrayHeader(pEnumNo, pComment);
924 // append to array list
925 CurrenArraySet->Append(ArrayHeader);
927 // append data to temp file
928 if(WriteArrayData(TmpDataFile, pBuffer) != 0) {
\r
930 #if DIGFILE_DEBUG_LEVEL > 0
\r
931 printf("** Error: writing data\n");
\r
944 // returns number of array sets in DIG file
946 int DIGFile::GetNoOfArraySets(unsigned int* pNoOfArraySets)
948 #if DIGFILE_DEBUG_LEVEL > 2
\r
949 fprintf(stderr, "DIGFile::GetNoOfArraySets\n");
\r
952 *pNoOfArraySets = ArraySets.getLength();
957 // returns number of arrays in current array set
959 int DIGFile::GetNoOfArrays(unsigned int* pNoOfArrays)
961 #if DIGFILE_DEBUG_LEVEL > 2
\r
962 fprintf(stderr, "DIGFile::GetNoOfArrays\n");
\r
965 if(CurrenArraySet == NULL) {
\r
967 #if DIGFILE_DEBUG_LEVEL > 0
\r
968 printf("** Error: no array set selected\n");
\r
970 return -1; // no array set selected
972 *pNoOfArrays = CurrenArraySet->getLength();
976 // returns array set header of selected array set
978 int DIGFile::GetArraySetHeader(DIGFileArraySetHeader** SetHeader)
980 *SetHeader = CurrenArraySet->ArraySetHeader;
985 // returns array header of selected array
988 int DIGFile::GetArrayHeader(DIGFileArrayHeader** ArrayHeader)
990 *ArrayHeader = CurrentArrayHeader;
995 int DIGFile::GetArraySetType(const char** pType)
997 #if DIGFILE_DEBUG_LEVEL > 2
\r
998 fprintf(stderr, "DIGFile::GetArraySetType\n");
\r
1001 if(CurrenArraySet == NULL) {
\r
1003 #if DIGFILE_DEBUG_LEVEL > 0
\r
1004 printf("** Error: no array set selected\n");
\r
1006 return -1; // no array set selected
1009 *pType = CurrenArraySet->ArraySetHeader->Type.Get();
1014 int DIGFile::GetArraySetTitle(const char** pTitle)
1016 #if DIGFILE_DEBUG_LEVEL > 2
\r
1017 fprintf(stderr, "DIGFile::GetArraySetTitle\n");
\r
1020 if(CurrenArraySet == NULL) {
\r
1022 #if DIGFILE_DEBUG_LEVEL > 0
\r
1023 printf("** Error: no array set selected\n");
\r
1025 return -1; // no array set selected
1028 *pTitle = CurrenArraySet->ArraySetHeader->Title.Get();
1033 int DIGFile::GetArraySetParameters(const char** pParameters)
1035 #if DIGFILE_DEBUG_LEVEL > 2
\r
1036 fprintf(stderr, "DIGFile::GetArraySetParameters\n");
\r
1039 if(CurrenArraySet == NULL) {
\r
1041 #if DIGFILE_DEBUG_LEVEL > 0
\r
1042 printf("** Error: no array set selected\n");
\r
1044 return -1; // no array set selected
1047 *pParameters = CurrenArraySet->ArraySetHeader->Parameters.Get();
1052 int DIGFile::GetArraySetComment(const char** pComment)
1054 #if DIGFILE_DEBUG_LEVEL > 2
\r
1055 fprintf(stderr, "DIGFile::GetArraySetComment\n");
\r
1058 if(CurrenArraySet == NULL) {
\r
1060 #if DIGFILE_DEBUG_LEVEL > 0
\r
1061 printf("** Error: no array set selected\n");
\r
1063 return -1; // no array set selected
1066 *pComment = CurrenArraySet->ArraySetHeader->Comment.Get();
1071 int DIGFile::GetArrayEnumNo(unsigned int* pEnumNo)
1073 #if DIGFILE_DEBUG_LEVEL > 2
\r
1074 fprintf(stderr, "DIGFile::GetArrayEnumNo\n");
\r
1077 if(CurrenArraySet == NULL) {
\r
1079 #if DIGFILE_DEBUG_LEVEL > 0
\r
1080 printf("** Error: no array set selected\n");
\r
1082 return -1; // no array set selected
1085 *pEnumNo = CurrentArrayHeader->EnumNo;
1090 int DIGFile::GetArrayComment(const char** pComment)
1092 #if DIGFILE_DEBUG_LEVEL > 2
\r
1093 fprintf(stderr, "DIGFile::GetArrayComment\n");
\r
1096 if(CurrenArraySet == NULL) {
\r
1098 #if DIGFILE_DEBUG_LEVEL > 0
\r
1099 printf("** Error: no array set selected\n");
\r
1101 return -1; // no array set selected
1104 *pComment = CurrentArrayHeader->Comment.Get();
1109 // selects array set
1111 int DIGFile::SelectArraySet(unsigned int No)
1113 #if DIGFILE_DEBUG_LEVEL > 2
\r
1114 fprintf(stderr, "DIGFile::SelectArraySet\n");
\r
1117 CurrentArrayHeader = NULL;
1118 return ArraySets.getArraySet(&CurrenArraySet, No);
1122 // selects array from current array set
1124 int DIGFile::SelectArray(unsigned int No)
1126 #if DIGFILE_DEBUG_LEVEL > 2
\r
1127 fprintf(stderr, "DIGFile::SelectArray\n");
\r
1130 if(CurrenArraySet == NULL) {
\r
1132 #if DIGFILE_DEBUG_LEVEL > 0
\r
1133 printf("** Error: no array set selected\n");
\r
1138 CurrenArrayIndex = CurrenArraySet->FirstArrayOffset + No;
1140 return CurrenArraySet->getArrayHeader(&CurrentArrayHeader, No);
1144 // returns data of selected array
1146 int DIGFile::GetArrayData(void* ArrayData)
1148 #if DIGFILE_DEBUG_LEVEL > 2
\r
1149 fprintf(stderr, "DIGFile::GetArrayData\n");
\r
1152 if(CurrenArraySet == NULL) {
\r
1154 #if DIGFILE_DEBUG_LEVEL > 0
\r
1155 printf("** Error: no array set selected\n");
\r
1160 //type of CurrentArrayOffset changed from unsigned int to off_t
1161 //to enable large file support (>2GB)
1162 //jklukowska, 06/07/2007
1163 off_t CurrenArrayOffset = static_cast <off_t>(XMLHeaderLength) +
1164 static_cast <off_t> (CurrenArrayIndex) * static_cast <off_t>(ArrayBufferSize);
1165 //unsigned int CurrenArrayOffset = XMLHeaderLength + CurrenArrayIndex * ArrayBufferSize;
1167 //fseek() changed to fseeko() to enable large file support (>2GB)
1168 //jklukowska, 06/07/2007
1169 if(fseeko(File, CurrenArrayOffset, SEEK_SET) != 0) {
1170 //if(fseek(File, CurrenArrayOffset, SEEK_SET) != 0) {
\r
1172 #if DIGFILE_DEBUG_LEVEL > 0
\r
1173 printf("** Error: seek error\n");
\r
1178 switch(MainHeader.DataFormat) {
1179 case DIGDataFormat_ASCII:
\r
1181 #if DIGFILE_DEBUG_LEVEL > 0
\r
1182 printf("** Error: Reading ASCII DIGFiles not supported\n");
\r
1184 return -1; // Reading ASCII DIGFiles not supported
1186 switch(MainHeader.DataType) {
1188 case DIGDataType_BOOL:
1189 for(i = 0; i < NoOfArrayItems; i++) {
1190 if(((unsigned char*) ArrayData)[i] == 0) {
1191 if(fprintf(f, " 0") < 0) {
1196 if(fprintf(f, " 1") < 0) {
1203 case DIGDataType_UCHAR:
1204 for(i = 0; i < NoOfArrayItems; i++) {
1205 if(fprintf(f, " %u", ((unsigned char*) ArrayData)[i]) < 0) {
1211 case DIGDataType_CHAR:
1212 for(i = 0; i < NoOfArrayItems; i++) {
1213 if(fprintf(f, " %i", ((char*) ArrayData)[i]) < 0) {
1219 case DIGDataType_USHORT:
1220 for(i = 0; i < NoOfArrayItems; i++) {
1221 if(fprintf(f, " %u", ((unsigned short*) ArrayData)[i]) < 0) {
1227 case DIGDataType_SHORT:
1228 for(i = 0; i < NoOfArrayItems; i++) {
1229 if(fprintf(f, " %i", ((short*) ArrayData)[i]) < 0) {
1235 case DIGDataType_UINT:
1236 for(i = 0; i < NoOfArrayItems; i++) {
1237 if(fprintf(f, " %u", ((unsigned int*) ArrayData)[i]) < 0) {
1243 case DIGDataType_INT:
1244 for(i = 0; i < NoOfArrayItems; i++) {
1245 if(fprintf(f, " %i", ((int*) ArrayData)[i]) < 0) {
1251 case DIGDataType_FLOAT:
1252 for(i = 0; i < NoOfArrayItems; i++) {
1253 if(fprintf(f, " %f", ((double) ((float*) ArrayData)[i])) < 0) {
1259 case DIGDataType_DOUBLE:
1260 for(i = 0; i < NoOfArrayItems; i++) {
1261 if(fprintf(f, " %f", ((double*) ArrayData)[i]) < 0) {
1273 case DIGDataFormat_BINARY:
1275 // read data bytes from the file
1276 if(fread(ArrayData, sizeof(char), ArrayBufferSize, File) != ArrayBufferSize) {
\r
1278 #if DIGFILE_DEBUG_LEVEL > 0
\r
1279 printf("** Error: Reading binary data\n");
\r
1284 // if file endian different than current machine flip bytes
1285 if(Endian != DIG_ENDIAN) {
1289 switch(MainHeader.DataType) {
1292 case DIGDataType_BOOL:
1293 case DIGDataType_UCHAR:
1294 case DIGDataType_CHAR:
1295 // bytes formats are in right order
1299 case DIGDataType_USHORT:
1300 case DIGDataType_SHORT:
1301 for(i = 0; i < NoOfArrayItems; i++) {
1304 *((char*) &val) = ((char*) ArrayData)[2 * i + 1];
1305 *(((char*) &val) + 1) = ((char*) ArrayData)[2 * i];
1307 ((short*) ArrayData)[i] = val;
1312 case DIGDataType_UINT:
1313 case DIGDataType_INT:
1314 case DIGDataType_FLOAT:
1315 for(i = 0; i < NoOfArrayItems; i++) {
1318 *((char*) &val) = ((char*) ArrayData)[4 * i + 3];
1319 *(((char*) &val) + 1) = ((char*) ArrayData)[4 * i + 2];
1320 *(((char*) &val) + 2) = ((char*) ArrayData)[4 * i + 1];
1321 *(((char*) &val) + 3) = ((char*) ArrayData)[4 * i];
1323 ((int*) ArrayData)[i] = val;
1328 case DIGDataType_DOUBLE:
1329 for(i = 0; i < NoOfArrayItems; i++) {
1332 *((char*) &val) = ((char*) ArrayData)[8 * i + 7];
1333 *(((char*) &val) + 1) = ((char*) ArrayData)[8 * i + 6];
1334 *(((char*) &val) + 2) = ((char*) ArrayData)[8 * i + 5];
1335 *(((char*) &val) + 3) = ((char*) ArrayData)[8 * i + 4];
1336 *(((char*) &val) + 4) = ((char*) ArrayData)[8 * i + 3];
1337 *(((char*) &val) + 5) = ((char*) ArrayData)[8 * i + 2];
1338 *(((char*) &val) + 6) = ((char*) ArrayData)[8 * i + 1];
1339 *(((char*) &val) + 7) = ((char*) ArrayData)[8 * i];
1341 ((double*) ArrayData)[i] = val;
1347 #if DIGFILE_DEBUG_LEVEL > 0
\r
1348 printf("** Error: unknown data type\n");
\r
1357 #if DIGFILE_DEBUG_LEVEL > 0
\r
1358 printf("** Error: unknown data format\n");
\r
1367 int DIGFile::WriteArrayData(FILE* f, const void* ArrayData)
1369 #if DIGFILE_DEBUG_LEVEL > 2
\r
1370 fprintf(stderr, "DIGFile::WriteArrayData\n");
\r
1375 switch(MainHeader.DataFormat) {
1376 case DIGDataFormat_ASCII:
1377 switch(MainHeader.DataType) {
1379 case DIGDataType_BOOL:
1380 for(i = 0; i < NoOfArrayItems; i++) {
1381 if(((unsigned char*) ArrayData)[i] == 0) {
1382 if(fprintf(f, " 0") < 0) {
\r
1384 #if DIGFILE_DEBUG_LEVEL > 0
\r
1385 printf("** Error: writing data\n");
\r
1391 if(fprintf(f, " 1") < 0) {
\r
1393 #if DIGFILE_DEBUG_LEVEL > 0
\r
1394 printf("** Error: writing data\n");
\r
1402 case DIGDataType_UCHAR:
1403 for(i = 0; i < NoOfArrayItems; i++) {
1404 if(fprintf(f, " %u", ((unsigned char*) ArrayData)[i]) < 0) {
\r
1406 #if DIGFILE_DEBUG_LEVEL > 0
\r
1407 printf("** Error: writing data\n");
\r
1414 case DIGDataType_CHAR:
1415 for(i = 0; i < NoOfArrayItems; i++) {
1416 if(fprintf(f, " %i", ((char*) ArrayData)[i]) < 0) {
\r
1418 #if DIGFILE_DEBUG_LEVEL > 0
\r
1419 printf("** Error: writing data\n");
\r
1426 case DIGDataType_USHORT:
1427 for(i = 0; i < NoOfArrayItems; i++) {
1428 if(fprintf(f, " %u", ((unsigned short*) ArrayData)[i]) < 0) {
\r
1430 #if DIGFILE_DEBUG_LEVEL > 0
\r
1431 printf("** Error: writing data\n");
\r
1438 case DIGDataType_SHORT:
1439 for(i = 0; i < NoOfArrayItems; i++) {
1440 if(fprintf(f, " %i", ((short*) ArrayData)[i]) < 0) {
\r
1442 #if DIGFILE_DEBUG_LEVEL > 0
\r
1443 printf("** Error: writing data\n");
\r
1450 case DIGDataType_UINT:
1451 for(i = 0; i < NoOfArrayItems; i++) {
1452 if(fprintf(f, " %u", ((unsigned int*) ArrayData)[i]) < 0) {
\r
1454 #if DIGFILE_DEBUG_LEVEL > 0
\r
1455 printf("** Error: writing data\n");
\r
1462 case DIGDataType_INT:
1463 for(i = 0; i < NoOfArrayItems; i++) {
1464 if(fprintf(f, " %i", ((int*) ArrayData)[i]) < 0) {
\r
1466 #if DIGFILE_DEBUG_LEVEL > 0
\r
1467 printf("** Error: writing data\n");
\r
1474 case DIGDataType_FLOAT:
1475 for(i = 0; i < NoOfArrayItems; i++) {
1476 if(fprintf(f, " %f", ((double) ((float*) ArrayData)[i])) < 0) {
\r
1478 #if DIGFILE_DEBUG_LEVEL > 0
\r
1479 printf("** Error: writing data\n");
\r
1486 case DIGDataType_DOUBLE:
1487 for(i = 0; i < NoOfArrayItems; i++) {
1488 if(fprintf(f, " %f", ((double*) ArrayData)[i]) < 0) {
\r
1490 #if DIGFILE_DEBUG_LEVEL > 0
\r
1491 printf("** Error: writing data\n");
\r
1500 #if DIGFILE_DEBUG_LEVEL > 0
\r
1501 printf("** Error: unknown data type\n");
\r
1507 case DIGDataFormat_BINARY:
1508 // write data in curent machine endian
1509 if(fwrite(ArrayData, sizeof(char),ArrayBufferSize, f) != ArrayBufferSize) {
1513 switch(MainHeader.DataType) {
1515 case DIGDataType_BOOL:
1516 if(fwrite(ArrayData, sizeof(char), NoOfArrayItems, f) != NoOfArrayItems) {
1521 case DIGDataType_UCHAR:
1522 if(fwrite(ArrayData, sizeof(unsigned char), NoOfArrayItems, f) != NoOfArrayItems) {
1527 case DIGDataType_CHAR:
1528 if(fwrite(ArrayData, sizeof(char), NoOfArrayItems, f) != NoOfArrayItems) {
1533 case DIGDataType_USHORT:
1534 if(fwrite(ArrayData, sizeof(unsigned short), NoOfArrayItems, f) != NoOfArrayItems) {
1539 case DIGDataType_SHORT:
1540 if(fwrite(ArrayData, sizeof(short), NoOfArrayItems, f) != NoOfArrayItems) {
1545 case DIGDataType_UINT:
1546 if(fwrite(ArrayData, sizeof(unsigned int), NoOfArrayItems, f) != NoOfArrayItems) {
1551 case DIGDataType_INT:
1552 if(fwrite(ArrayData, sizeof(int), NoOfArrayItems, f) != NoOfArrayItems) {
1557 case DIGDataType_FLOAT:
1558 if(fwrite(ArrayData, sizeof(float), NoOfArrayItems, f) != NoOfArrayItems) {
1563 case DIGDataType_DOUBLE:
1564 if(fwrite(ArrayData, sizeof(double), NoOfArrayItems, f) != NoOfArrayItems) {
1577 #if DIGFILE_DEBUG_LEVEL > 0
\r
1578 printf("** Error: unknown data format\n");
\r
1587 //////////////////////////////////////////////////////////////////////////////////////
1589 // XML Parsing functions
1591 //////////////////////////////////////////////////////////////////////////////////////
1593 int DIGFile::GetUintAttributeValue(DOMElement* Element, const XMLCh* AttributeName, unsigned int* value)
1595 #if DIGFILE_DEBUG_LEVEL > 2
\r
1596 fprintf(stderr, "DIGFile::GetUintAttributeValue\n");
\r
1599 const XMLCh* AttributeValueXMLStr;
1600 const char* AttributeValueStr;
1601 AttributeValueXMLStr = Element->getAttribute(AttributeName);
1603 AttributeValueStr = XMLString::transcode(AttributeValueXMLStr);
1605 //delete AttributeValueXMLStr;
1607 if((*value = atoi(AttributeValueStr)) < 0) {
\r
1609 #if DIGFILE_DEBUG_LEVEL > 0
\r
1610 printf("** Error: invalid unsigned int value\n");
\r
1615 /* // direct conversion ?
1617 bool XMLString::textToBin(const XMLCh *const toConvert,
1618 unsigned int & toFill ) [static]
1624 int DIGFile::GetIntAttributeValue(DOMElement* Element, const XMLCh* AttributeName, int* value)
1626 #if DIGFILE_DEBUG_LEVEL > 2
\r
1627 fprintf(stderr, "DIGFile::GetIntAttributeValue\n");
\r
1630 const XMLCh* AttributeValueXMLStr;
1631 const char* AttributeValueStr;
1632 AttributeValueXMLStr = Element->getAttribute(AttributeName);
1634 AttributeValueStr = XMLString::transcode(AttributeValueXMLStr);
1636 //delete AttributeValueXMLStr;
1638 *value = atoi(AttributeValueStr);
1640 /* // direct conversion ?
1642 bool XMLString::textToBin(const XMLCh *const toConvert,
1643 unsigned int & toFill ) [static]
1649 int DIGFile::GetDoubleAttributeValue(DOMElement* Element, const XMLCh* AttributeName, double* value)
1651 #if DIGFILE_DEBUG_LEVEL > 2
\r
1652 fprintf(stderr, "DIGFile::GetDoubleAttributeValue\n");
\r
1655 const XMLCh* AttributeValueXMLStr;
1656 const char* AttributeValueStr;
1657 AttributeValueXMLStr = Element->getAttribute(AttributeName);
1659 AttributeValueStr = XMLString::transcode(AttributeValueXMLStr);
1661 //delete AttributeValueXMLStr;
1663 *value = atof(AttributeValueStr);
1665 /* // direct conversion ?
1667 bool XMLString::textToBin(const XMLCh *const toConvert,
1668 unsigned int & toFill ) [static]
1675 int DIGFile::GetTxtAttributeValue(DOMElement* Element, const XMLCh* AttributeName, char** Text)
1677 #if DIGFILE_DEBUG_LEVEL > 2
\r
1678 fprintf(stderr, "DIGFile::GetTxtAttributeValue\n");
\r
1681 const XMLCh* AttributeValueXMLStr;
1683 AttributeValueXMLStr = Element->getAttribute(AttributeName);
1685 *Text = XMLString::transcode(AttributeValueXMLStr);
1691 int DIGFile::GetElementText(DOMElement* Element, char** Text)
1693 #if DIGFILE_DEBUG_LEVEL > 2
\r
1694 fprintf(stderr, "DIGFile::GetElementText\n");
\r
1698 DOMNodeList* Children = Element->getChildNodes();
1700 // search for first instance of text node
1701 for(unsigned int i = 0; i < Children->getLength(); i++) {
1702 //const XMLCh* CXMLStr = Children->item(i)->getNodeName();
1703 if(Children->item(i)->getNodeType() == DOMNode::TEXT_NODE) {
1704 const XMLCh* CXMLStr = Children->item(i)->getNodeValue();
1705 *Text = XMLString::transcode(CXMLStr);
1710 #if DIGFILE_DEBUG_LEVEL > 0
\r
1711 printf("** Error: Parsing - text node not found\n");
\r
1713 return -1; // text node not found
1716 DOMNodeList* TextList = CommentsElement->getElementsByTagName(XMLString::transcode("text"));
1717 DOMNode* TextNode = TextList->item(0);
1718 const XMLCh* TextXMLStr = TextNode->getNodeValue();
1719 char* c = XMLString::transcode(TextXMLStr);
1724 int DIGFile::SymbolToCode(char* Symbol, const char** SymbolTable, int NumberOfSymbols)
1726 #if DIGFILE_DEBUG_LEVEL > 2
\r
1727 fprintf(stderr, "DIGFile::SymbolToCode\n");
\r
1730 for (int num = 0; num < NumberOfSymbols; num++) {
1731 if(strcmp(SymbolTable[num], Symbol) == 0) {
1736 #if DIGFILE_DEBUG_LEVEL > 0
\r
1737 printf("** Error: Parsing - symbol not found\n");
\r
1739 return -1; // symbol not found
1742 int DIGFile::InitParser2(const MemBufInputSource& memBufIS)
1744 #if DIGFILE_DEBUG_LEVEL > 2
\r
1745 fprintf(stderr, "DIGFile::InitParser2\n");
\r
1750 XMLPlatformUtils::Initialize();
1752 catch(const XMLException &toCatch) {
1753 std::cerr << "Error during Xerces-c Initialization.\n"
1754 << " Exception message:"
1755 << StrX(toCatch.getMessage()) << std::endl;
1759 // Create our parser, then attach an error handler to the parser.
1760 // The parser will call back to methods of the ErrorHandler if it
1761 // discovers errors during the course of parsing the XML document.
1762 parser = new XercesDOMParser;
1763 parser->setValidationScheme(XercesDOMParser::Val_Auto);
1764 parser->setDoNamespaces(false);
1765 parser->setDoSchema(true);
1766 parser->setValidationSchemaFullChecking(true);
1767 parser->setCreateEntityReferenceNodes(true);
1768 errReporter = new DOMTreeErrorReporter();
1769 parser->setErrorHandler(errReporter);
1771 // Parse the XML file, catching any XML exceptions that might propogate
1774 parser->parse(memBufIS);
1776 catch (const XMLException& e) {
1777 std::cerr << "An error occurred during parsing\n Message: "
1778 << StrX(e.getMessage()) << std::endl;
1781 catch (const DOMException& e) {
1782 std::cerr << "A DOM error occurred during parsing\n DOMException code: "
1783 << e.code << std::endl;
1787 std::cerr << "An error occurred during parsing\n " << std::endl;
1791 Document = ((AbstractDOMParser*)parser)->getDocument();
1794 RootElement = Document->getDocumentElement();
1796 // get main header node
1797 DOMNodeList* MainHeaderList = RootElement->getElementsByTagName(XMLString::transcode("main_header"));
1798 MainHeaderElement = (DOMElement*) MainHeaderList->item(0);
1800 // get application header node
1801 DOMNodeList* ApplicationHeaderList = RootElement->getElementsByTagName(XMLString::transcode("application_header"));
1802 ApplicationHeaderElement = (DOMElement*) ApplicationHeaderList->item(0);
1804 // get array set header nodes
1805 ArraySetHeaderList = RootElement->getElementsByTagName(XMLString::transcode("array_set_header"));
1806 DIGFileArraySetHeader* ArraySetHeader = new DIGFileArraySetHeader();
1808 // select fisrt array set
1809 GetArraySetHeader(ArraySetHeader, 0);
1815 int DIGFile::GetMainHeader(DIGFileMainHeader* MainHeader)
1817 #if DIGFILE_DEBUG_LEVEL > 2
\r
1818 fprintf(stderr, "DIGFile::InitParser2\n");
\r
1823 // get header attributes
1827 if(GetTxtAttributeValue(MainHeaderElement, TypeXMLStr, &Type) != 0) {
1833 if(GetTxtAttributeValue(MainHeaderElement, TitleXMLStr, &Title) != 0) {
1839 if(GetIntAttributeValue(MainHeaderElement, ChannelsXMLStr, &Channels) != 0) {
1843 // get Number of Arrays
1845 if(GetIntAttributeValue(MainHeaderElement, NumberOfArraysXMLStr, &NumberOfArrays) != 0) {
1849 // get Number of Array Sets
1851 if(GetIntAttributeValue(MainHeaderElement, NumberOfArraySetsXMLStr, &NumberOfSets) != 0) {
1856 if(GetTxtAttributeValue(MainHeaderElement, EndianXMLStr, &AttrValStr) != 0) {
1860 if((Endian = (DIGEndian) SymbolToCode(AttrValStr, DIGEndianStr, DIGEndianSize)) < 0) {
1865 if(GetTxtAttributeValue(MainHeaderElement, ValueTypeXMLStr, &AttrValStr) != 0) {
1870 DIGValueType ValueType;
1871 if((ValueType = (DIGValueType) SymbolToCode(AttrValStr, DIGValueTypeStr, DIGValueTypeSize)) < 0) {
1876 if(GetTxtAttributeValue(MainHeaderElement, DataTypeXMLStr, &AttrValStr) != 0) {
1880 DIGDataType DataType;
1881 if((DataType = (DIGDataType) SymbolToCode(AttrValStr, DIGDataTypeStr, DIGDataTypeSize)) < 0) {
1886 if(GetTxtAttributeValue(MainHeaderElement, DataFormatXMLStr, &AttrValStr) != 0) {
1890 DIGDataFormat DataFormat;
1891 if((DataFormat = (DIGDataFormat) SymbolToCode(AttrValStr, DIGDataFormatStr, DIGDataFormatSize)) < 0) {
1896 if(GetTxtAttributeValue(MainHeaderElement, GridTypeXMLStr, &AttrValStr) != 0) {
1901 if((Grid = (DIGGrid) SymbolToCode(AttrValStr, DIGGridStr, DIGGridSize)) < 0) {
1905 // get Basis Function
1906 if(GetTxtAttributeValue(MainHeaderElement, BasisFunctionXMLStr, &AttrValStr) != 0) {
1911 if((Basis = (DIGBasis) SymbolToCode(AttrValStr, DIGBasisStr, DIGBasisSize)) < 0) {
1916 if(GetTxtAttributeValue(MainHeaderElement, UnitXMLStr, &AttrValStr) != 0) {
1921 if((Unit = (DIGUnit) SymbolToCode(AttrValStr, DIGUnitStr, DIGUnitSize)) < 0) {
1927 if(GetTxtAttributeValue(MainHeaderElement, OtherUnitXMLStr, &OtherUnit) != 0) {
1931 // get other header values
1933 // get Comment Element
1935 char* Comment = DIGEmptyStr;
1937 DOMNodeList* CommentsList = MainHeaderElement->getElementsByTagName(CommentsXMLStr);
1939 int tNumC = CommentsList->getLength();
1942 DOMElement* CommentsElement = (DOMElement*) CommentsList->item(0);
1945 if(GetElementText(CommentsElement, &Comment) != 0) {
1946 ;// allow empty comments
1950 DIGDimensions Dimensions;
1952 DOMNodeList* DimensionsList = MainHeaderElement->getElementsByTagName(DimensionsXMLStr);
1953 DOMElement* DimensionsElement = (DOMElement*) DimensionsList->item(0);
1956 if(GetIntAttributeValue(DimensionsElement, DimmensionXXMLStr, &(Dimensions.x)) != 0) {
1961 if(GetIntAttributeValue(DimensionsElement, DimmensionYXMLStr, &(Dimensions.y)) != 0) {
1966 if(GetIntAttributeValue(DimensionsElement, DimmensionZXMLStr, &(Dimensions.z)) != 0) {
1970 // get Sampling Rate X
1971 DIGSampling SamplingX;
1973 DOMNodeList* SamplingXList = MainHeaderElement->getElementsByTagName(SamplingRateXXMLStr);
1974 DOMElement* SamplingXElement = (DOMElement*) SamplingXList->item(0);
1977 if(GetDoubleAttributeValue(SamplingXElement, DimmensionXXMLStr, &(SamplingX.x)) != 0) {
1981 if(GetDoubleAttributeValue(SamplingXElement, DimmensionYXMLStr, &(SamplingX.y)) != 0) {
1985 if(GetDoubleAttributeValue(SamplingXElement, DimmensionZXMLStr, &(SamplingX.z)) != 0) {
1990 // get Sampling Rate Y
1991 DIGSampling SamplingY;
1993 DOMNodeList* SamplingYList = MainHeaderElement->getElementsByTagName(SamplingRateYXMLStr);
1994 DOMElement* SamplingYElement = (DOMElement*) SamplingYList->item(0);
1997 if(GetDoubleAttributeValue(SamplingYElement, DimmensionXXMLStr, &(SamplingY.x)) != 0) {
2001 if(GetDoubleAttributeValue(SamplingYElement, DimmensionYXMLStr, &(SamplingY.y)) != 0) {
2005 if(GetDoubleAttributeValue(SamplingYElement, DimmensionZXMLStr, &(SamplingY.z)) != 0) {
2009 // get Sampling Rate Z
2010 DIGSampling SamplingZ;
2012 DOMNodeList* SamplingZList = MainHeaderElement->getElementsByTagName(SamplingRateZXMLStr);
2013 DOMElement* SamplingZElement = (DOMElement*) SamplingZList->item(0);
2016 if(GetDoubleAttributeValue(SamplingZElement, DimmensionXXMLStr, &(SamplingZ.x)) != 0) {
2020 if(GetDoubleAttributeValue(SamplingZElement, DimmensionYXMLStr, &(SamplingZ.y)) != 0) {
2024 if(GetDoubleAttributeValue(SamplingZElement, DimmensionZXMLStr, &(SamplingZ.z)) != 0) {
2028 NoOfArrays = NumberOfArrays;
2029 NoOfSets = NumberOfSets;
2031 MainHeader->Title.Set(Title);
2032 MainHeader->Type.Set(Type);
2033 MainHeader->Channels = Channels;
2034 //MainHeader->Endian = Endian;
2035 MainHeader->ValueType = ValueType;
2036 MainHeader->DataType = DataType;
2037 MainHeader->DataFormat = DataFormat;
2038 MainHeader->Grid = Grid;
2039 MainHeader->Basis = Basis;
2040 MainHeader->Unit = Unit;
2041 MainHeader->OtherUnit.Set(OtherUnit);
2042 MainHeader->Comment.Set(Comment);
2043 MainHeader->Dimensions = Dimensions;
2044 MainHeader->SamplingX = SamplingX;
2045 MainHeader->SamplingY = SamplingY;
2046 MainHeader->SamplingZ = SamplingZ;
2051 int DIGFile::ParseApplicationHeader() {
\r
2052 #if DIGFILE_DEBUG_LEVEL > 2
\r
2053 fprintf(stderr, "DIGFile::ParseApplicationHeader\n");
\r
2059 int DIGFile::GetArraySetHeader(DIGFileArraySetHeader* ArraySetHeader, unsigned int index)
2061 #if DIGFILE_DEBUG_LEVEL > 2
\r
2062 fprintf(stderr, "DIGFile::GetArraySetHeader\n");
\r
2065 if(index > ArraySetHeaderList->getLength()) {
\r
2067 #if DIGFILE_DEBUG_LEVEL > 0
\r
2068 printf("** Error: index out of range\n");
\r
2070 // error index out of range
2073 DOMElement* ArraySetHeaderElement = (DOMElement*) ArraySetHeaderList->item(index);
2075 // get Array Set Header Attributes
2079 if(GetTxtAttributeValue(ArraySetHeaderElement, TypeXMLStr, &Type) != 0) {
2085 if(GetTxtAttributeValue(ArraySetHeaderElement, TitleXMLStr, &Title) != 0) {
2089 // get Comment Element
2090 char* Comment = DIGEmptyStr;
2092 DOMNodeList* CommentsList = ArraySetHeaderElement->getElementsByTagName(CommentsXMLStr);
2094 int tNumC = CommentsList->getLength();
2097 DOMElement* CommentsElement = (DOMElement*) CommentsList->item(0);
2100 if(GetElementText(CommentsElement, &Comment) != 0) {
2101 ;// allow empty comments
2105 // get Parameters Element
2106 DOMNodeList* ParametersList = ArraySetHeaderElement->getElementsByTagName(ParametersXMLStr);
2107 DOMElement* ParametersElement = (DOMElement*) ParametersList->item(0);
2109 // get Parameters Text
2111 if(GetElementText(ParametersElement, &Parameters) != 0) {
2113 Parameters = DIGEmptyStr;
2116 ArraySetHeader->Type.Set(Type);
2117 ArraySetHeader->Title.Set(Title);
2118 ArraySetHeader->Comment.Set(Comment);
2119 ArraySetHeader->Parameters.Set(Parameters);
2122 ArrayHeaderList = ArraySetHeaderElement->getElementsByTagName(ArrayHeaderXMLStr);
2128 int DIGFile::GetArrayHeader(DIGFileArrayHeader* ArrayHeader, unsigned int index)
2130 #if DIGFILE_DEBUG_LEVEL > 2
\r
2131 fprintf(stderr, "DIGFile::GetArrayHeader\n");
\r
2134 if(index > ArrayHeaderList->getLength()) {
2135 // error index out of range
2138 DOMElement* ArrayHeaderElement = (DOMElement*) ArrayHeaderList->item(index);
2140 // get Array Header Attributes
2142 // get Enumeration Number
2145 if(GetIntAttributeValue(ArrayHeaderElement, EnumerationNumberXMLStr, &EnumNo) != 0) {
2149 // get Comment Element
2150 char* Comment = DIGEmptyStr;
2152 DOMNodeList* CommentsList = ArrayHeaderElement->getElementsByTagName(CommentsXMLStr);
2154 int tNumC = CommentsList->getLength();
2157 DOMElement* CommentsElement = (DOMElement*) CommentsList->item(0);
2160 if(GetElementText(CommentsElement, &Comment) != 0) {
2161 ;// allow empty comments
2165 ArrayHeader->EnumNo = EnumNo;
2166 ArrayHeader->Comment.Set(Comment);
2172 int DIGFile::ResetParser()
2174 #if DIGFILE_DEBUG_LEVEL > 2
\r
2175 fprintf(stderr, "DIGFile::ResetParser\n");
\r
2178 // Clean up the error handler. The parser does not adopt handlers
2179 // since they could be many objects or one object installed for multiple
2183 // Delete the parser itself. Must be done prior to calling Terminate, below.
2186 // And call the termination method
2187 XMLPlatformUtils::Terminate();
2193 int DIGFile::ParseXML(const char* MemBuf)
2195 #if DIGFILE_DEBUG_LEVEL > 2
\r
2196 fprintf(stderr, "DIGFile::ParseXML\n");
\r
2199 static const char* gMemBufId = "XMLHeader";
2201 MemBufInputSource* memBufIS = new MemBufInputSource
2203 (const XMLByte*)MemBuf,
2209 // initialize parser and pharse root
2210 if(InitParser2(*memBufIS) != 0) {
\r
2212 #if DIGFILE_DEBUG_LEVEL > 0
\r
2213 printf("** Error: initializing parser and gtting doument root\n");
\r
2218 // parse main header
2219 if(GetMainHeader(&MainHeader)) {
\r
2221 #if DIGFILE_DEBUG_LEVEL > 0
\r
2222 printf("** Error: parsing main header\n");
\r
2227 // parse application header
2228 if(ParseApplicationHeader()) {
\r
2230 #if DIGFILE_DEBUG_LEVEL > 0
\r
2231 printf("** Error: parsing application header\n");
\r
2236 // parse arrayset headers
2237 unsigned int NumberOfArrays = 0;
2239 for(unsigned int i = 0; i < ArraySetHeaderList->getLength(); i++) {
2241 // create new array set
2242 ArraySet* ASet = new ArraySet;
2243 ASet->FirstArrayOffset = NumberOfArrays;
2245 // create new array set header
2246 ASet->ArraySetHeader = new DIGFileArraySetHeader;
2248 // load it with data
2249 if(GetArraySetHeader(ASet->ArraySetHeader, i) != 0) {
\r
2251 #if DIGFILE_DEBUG_LEVEL > 0
\r
2252 printf("** Error: parsing array set header\n");
\r
2258 for(unsigned int j = 0; j < ArrayHeaderList->getLength(); j++) {
2260 // create new array header
2261 DIGFileArrayHeader* ArrayHeader = new DIGFileArrayHeader;
2263 // load it with data
2264 if(GetArrayHeader(ArrayHeader, j) != 0) {
\r
2266 #if DIGFILE_DEBUG_LEVEL > 0
\r
2267 printf("** Error: parsing array header\n");
\r
2272 // append to array list
2273 ASet->Append(ArrayHeader);
2278 // append array set to array set list
2279 ArraySets.Append(ASet);
2282 if(NumberOfArrays != NoOfArrays) {
\r
2284 #if DIGFILE_DEBUG_LEVEL > 0
\r
2285 printf("** Error: invalid number of arrays\n");
\r
2295 //////////////////////////////////////////////////////////////////////////////////////
2297 // XML writing functions
2299 //////////////////////////////////////////////////////////////////////////////////////
2301 int DIGFile::WriteXMLHeader()
2303 #if DIGFILE_DEBUG_LEVEL > 2
\r
2304 fprintf(stderr, "DIGFile::WriteXMLHeader\n");
\r
2307 // create XML buffer
2308 XMLFormatTarget* mymFormTarget = new MemBufFormatTarget(4*1023);
2311 // create DOMDocument
2312 CreateRootElement();
2314 if(CreateMainHeader(&MainHeader) != 0) {
\r
2316 #if DIGFILE_DEBUG_LEVEL > 0
\r
2317 printf("** Error: creating main header\n");
\r
2322 if(CreateApplicationHeader() != 0) {
\r
2324 #if DIGFILE_DEBUG_LEVEL > 0
\r
2325 printf("** Error: creating application header\n");
\r
2330 // step through array sets
2331 for(unsigned int i = 0; i < ArraySets.getLength(); i++) {
2335 // get array set from set list
2336 if(ArraySets.getArraySet(&ASet, i) != 0) {
\r
2338 #if DIGFILE_DEBUG_LEVEL > 0
\r
2339 printf("** Error: creating array set header\n");
\r
2344 // write array set header
2345 AppendArraySetHeader(ASet->ArraySetHeader);
2347 // step through arrays
2348 for(unsigned int j = 0; j < ASet->getLength(); j++) {
2350 DIGFileArrayHeader* ArrayHeader;
2353 ASet->getArrayHeader(&ArrayHeader, j);
2355 // write array header
2356 AppendArrayHeader(ArrayHeader);
2363 ///DOMPrintFilter *myFilter = 0;
2366 // get a serializer, an instance of DOMWriter (kmr Now DOMLSSerializer)
2368 XMLString::transcode("LS", tempStr, 99);
2369 DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
2370 DOMLSSerializer *theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer();
2371 DOMConfiguration *dc = theSerializer->getDomConfig();
2372 DOMLSOutput* theOutput = ((DOMImplementationLS*)impl)->createLSOutput();
2373 theOutput->setByteStream(mymFormTarget);
2375 // set user specified end of line sequence and output encoding
2376 //theSerializer->setNewLine(gMyEOLSequence);
2378 theSerializer->setNewLine(XMLString::transcode("\x0A"));
2380 static XMLCh* gOutputEncoding = 0;
2382 // kmr theSerializer->setEncoding(gOutputEncoding);
2383 theOutput->setEncoding(gOutputEncoding);
2385 // plug in user's own filter
2388 // even we say to show attribute, but the DOMWriter
2389 // will not show attribute nodes to the filter as
2390 // the specs explicitly says that DOMWriter shall
2391 // NOT show attributes to DOMWriterFilter.
2393 // so DOMNodeFilter::SHOW_ATTRIBUTE has no effect.
2394 // same DOMNodeFilter::SHOW_DOCUMENT_TYPE, no effect.
2396 myFilter = new DOMPrintFilter(DOMNodeFilter::SHOW_ELEMENT |
2397 DOMNodeFilter::SHOW_ATTRIBUTE |
2398 DOMNodeFilter::SHOW_DOCUMENT_TYPE
2400 theSerializer->setFilter(myFilter);
2404 // plug in user's own error handler
2405 DOMErrorHandler* myErrorHandler = new DOMPrintErrorHandler();
2406 dc->setParameter(XMLUni::fgDOMErrorHandler,myErrorHandler);
2408 // set feature if the serializer supports the feature/mode
2410 static bool gSplitCdataSections = true;
2412 if(dc->canSetParameter(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections))
2413 dc->setParameter(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections);
2415 static bool gDiscardDefaultContent = true;
2417 if(dc->canSetParameter(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent))
2418 dc->setParameter(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent);
2420 static bool gFormatPrettyPrint = true;
2422 if(dc->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint))
2423 dc->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint);
2426 // Plug in a format target to receive the resultant
2427 // XML stream from the serializer.
2429 // StdOutFormatTarget prints the resultant XML stream
2430 // to stdout once it receives any thing from the serializer.
2433 //XMLFormatTarget* myFormTarget = new StdOutFormatTarget();
2434 //theSerializer->writeNode(myFormTarget, *Document);
2436 // get the DOM representation
2437 //DOMNode *doc = parser->getDocument();
2440 // do the serialization through DOMWriter::writeNode();
2442 //theSerializer->writeNode(myFormTarget, *Document);
2444 //XMLFormatTarget* myfFormTarget = new LocalFileFormatTarget("xxx");
2445 //theSerializer->writeNode(myfFormTarget, *Document);
2447 //((LocalFileFormatTarget*) myfFormTarget)->Target.setEscapeFlags();
2449 //kmr theSerializer->writeNode(mymFormTarget, *Document);
2450 theSerializer->write(Document, theOutput);
2452 delete theSerializer;
2455 // Filter, formatTarget and error handler
2456 // are NOT owned by the serializer.
2459 delete myErrorHandler;
2467 catch(XMLException& e) {
2468 std::cerr << "An error occurred during creation of output transcoder. Msg is:"
2470 << StrX(e.getMessage()) << std::endl;
2474 const XMLByte* XMLbuf = ((MemBufFormatTarget*) mymFormTarget)->getRawBuffer();
2476 fprintf(File, "%s", XMLbuf);
2478 delete mymFormTarget;
2484 // Create root element
2485 //void DIGFile::WritePrefix()
2486 void DIGFile::CreateRootElement()
2488 #if DIGFILE_DEBUG_LEVEL > 2
\r
2489 fprintf(stderr, "DIGFile::CreateRootElement\n");
\r
2492 Document = impl->createDocument(
2493 0, // root element namespace URI.
2494 RootXMLStr, // root element name
2495 0 // document type object (DTD).
2498 RootElement = Document->getDocumentElement();
2501 fprintf(File, "<?xml version=\"1.0\"?>\n\n");
2502 fprintf(File, "<DIG_DATA\n");
2503 fprintf(File, " xmlns:xsd=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
2504 fprintf(File, " xsd:noNamespcadSchemaLocation=\"%s DIGschema.xsd\"\n", SchemaName);
2505 fprintf (File, ">\n");
2510 // Create Main Header
2511 int DIGFile::CreateMainHeader(DIGFileMainHeader* header)
2513 #if DIGFILE_DEBUG_LEVEL > 2
\r
2514 fprintf(stderr, "DIGFile::CreateMainHeader\n");
\r
2519 // create main header node
2520 MainHeaderElement = Document->createElement(MainHeaderXMLStr);
2525 tmpXMLStr = XMLString::transcode(header->Type.Get());
2526 MainHeaderElement->setAttribute(TypeXMLStr, tmpXMLStr);
2530 tmpXMLStr = XMLString::transcode(header->Title.Get());
2531 MainHeaderElement->setAttribute(TitleXMLStr, tmpXMLStr);
2535 //tmpXMLStr = new XMLCh[5];
2536 //XMLString::binToText(header->Channels, tmpXMLStr, 4, 10);
2537 unsigned int maxchars = 1;
2538 if (header->Channels != 0)
2539 maxchars += static_cast<unsigned int>(log10(static_cast<double>(header->Channels)));
2540 tmpXMLStr = new XMLCh[maxchars+1];
2541 XMLString::binToText(header->Channels, tmpXMLStr, maxchars, 10);
2542 MainHeaderElement->setAttribute(ChannelsXMLStr, tmpXMLStr);
2545 // define number of arrays
2546 //tmpXMLStr = new XMLCh[5];
2547 //XMLString::binToText(NoOfArrays, tmpXMLStr, 4, 10);
2549 if (NoOfArrays != 0)
2550 maxchars += static_cast<unsigned int>(log10(static_cast<double>(NoOfArrays)));
2551 tmpXMLStr = new XMLCh[maxchars+1];
2552 XMLString::binToText(NoOfArrays, tmpXMLStr, maxchars, 10);
2553 MainHeaderElement->setAttribute(NumberOfArraysXMLStr, tmpXMLStr);
2556 // define number of array sets
2557 //tmpXMLStr = new XMLCh[5];
2558 //XMLString::binToText(NoOfSets, tmpXMLStr, 4, 10);
2561 maxchars += static_cast<unsigned int>(log10(static_cast<double>(NoOfSets)));
2562 tmpXMLStr = new XMLCh[maxchars+1];
2563 XMLString::binToText(NoOfSets, tmpXMLStr, maxchars, 10);
2564 MainHeaderElement->setAttribute(NumberOfArraySetsXMLStr, tmpXMLStr);
2567 // define endian according to curent machine type
2568 tmpXMLStr = XMLString::transcode(DIGEndianStr[static_cast<int>(DIG_ENDIAN)]);
2569 MainHeaderElement->setAttribute(EndianXMLStr, tmpXMLStr);
2572 // define value type
2573 tmpXMLStr = XMLString::transcode(DIGValueTypeStr[header->ValueType]);
2574 MainHeaderElement->setAttribute(ValueTypeXMLStr, tmpXMLStr);
2578 tmpXMLStr = XMLString::transcode(DIGDataTypeStr[header->DataType]);
2579 MainHeaderElement->setAttribute(DataTypeXMLStr, tmpXMLStr);
2582 // define data format
2583 tmpXMLStr = XMLString::transcode(DIGDataFormatStr[header->DataFormat]);
2584 MainHeaderElement->setAttribute(DataFormatXMLStr, tmpXMLStr);
2588 tmpXMLStr = XMLString::transcode(DIGGridStr[header->Grid]);
2589 MainHeaderElement->setAttribute(GridTypeXMLStr, tmpXMLStr);
2592 // define basis function
2593 tmpXMLStr = XMLString::transcode(DIGBasisStr[header->Basis]);
2594 MainHeaderElement->setAttribute(BasisFunctionXMLStr, tmpXMLStr);
2598 tmpXMLStr = XMLString::transcode(DIGUnitStr[header->Unit]);
2599 MainHeaderElement->setAttribute(UnitXMLStr, tmpXMLStr);
2602 // define other unit
2603 if(header->OtherUnit.Get() != NULL) {
2604 MainHeaderElement->setAttribute(OtherUnitXMLStr, XMLString::transcode(header->OtherUnit.Get()));
2611 if(header->Comment.Get() != NULL) {
2613 // create comments node
2614 DOMElement* Comments = Document->createElement(CommentsXMLStr);
2616 // create comments text node
2617 tmpXMLStr = XMLString::transcode(header->Comment.Get());
2618 DOMText* CommentText = Document->createTextNode(tmpXMLStr);
2620 Comments->appendChild(CommentText);
2622 // append comments to main header
2623 MainHeaderElement->appendChild(Comments);
2627 // create dimensions node
2628 DOMElement* Dimensions = Document->createElement(DimensionsXMLStr);
2630 const DIGDimensions* dim = &(header->Dimensions);
2632 // set dimension attributes
2633 //tmpXMLStr = new XMLCh[5];
2634 //XMLString::binToText(dim->x, tmpXMLStr, 4, 10);
2637 maxchars += static_cast<unsigned int>(log10(static_cast<double>(dim->x)));
\r
2639 tmpXMLStr = new XMLCh[maxchars+1];
2640 XMLString::binToText(dim->x, tmpXMLStr, maxchars, 10);
2641 Dimensions->setAttribute(DimmensionXXMLStr, tmpXMLStr);
2644 //XMLString::binToText(dim->y, tmpXMLStr, 4, 10);
2647 maxchars += static_cast<unsigned int>(log10(static_cast<double>(dim->y)));
\r
2649 tmpXMLStr = new XMLCh[maxchars+1];
2650 XMLString::binToText(dim->y, tmpXMLStr, maxchars, 10);
2651 Dimensions->setAttribute(DimmensionYXMLStr, tmpXMLStr);
2654 //XMLString::binToText(dim->z, tmpXMLStr, 4, 10);
2657 maxchars += static_cast<unsigned int>(log10(static_cast<double>(dim->z)));
\r
2659 tmpXMLStr = new XMLCh[maxchars+1];
2660 XMLString::binToText(dim->z, tmpXMLStr, maxchars, 10);
2661 Dimensions->setAttribute(DimmensionZXMLStr, tmpXMLStr);
2664 // append dimensions to main header
2665 MainHeaderElement->appendChild(Dimensions);
2668 // create sampling rate X node
2669 DOMElement* SamplingRateX = Document->createElement(SamplingRateXXMLStr);
2671 DIGSampling* sampX = &(header->SamplingX);
2673 // set sampling rate X attributes
2676 sprintf(valStr, "%f", sampX->x);
2677 tmpXMLStr = XMLString::transcode(valStr);
2678 SamplingRateX->setAttribute(DimmensionXXMLStr, tmpXMLStr);
2681 sprintf(valStr, "%f", sampX->y);
2682 tmpXMLStr = XMLString::transcode(valStr);
2683 SamplingRateX->setAttribute(DimmensionYXMLStr, tmpXMLStr);
2686 sprintf(valStr, "%f", sampX->z);
2687 tmpXMLStr = XMLString::transcode(valStr);
2688 SamplingRateX->setAttribute(DimmensionZXMLStr, tmpXMLStr);
2691 // append sampling rate X to main header
2692 MainHeaderElement->appendChild(SamplingRateX);
2695 // create sampling rate Y node
2696 DOMElement* SamplingRateY = Document->createElement(SamplingRateYXMLStr);
2698 DIGSampling* sampY = &(header->SamplingY);
2700 // set sampling rate Y attributes
2701 sprintf(valStr, "%f", sampY->x);
2702 tmpXMLStr = XMLString::transcode(valStr);
2703 SamplingRateY->setAttribute(DimmensionXXMLStr, tmpXMLStr);
2706 sprintf(valStr, "%f", sampY->y);
2707 tmpXMLStr = XMLString::transcode(valStr);
2708 SamplingRateY->setAttribute(DimmensionYXMLStr, tmpXMLStr);
2711 sprintf(valStr, "%f", sampY->z);
2712 tmpXMLStr = XMLString::transcode(valStr);
2713 SamplingRateY->setAttribute(DimmensionZXMLStr, tmpXMLStr);
2716 // append sampling rate Y to main header
2717 MainHeaderElement->appendChild(SamplingRateY);
2720 // create sampling rate Z node
2721 DOMElement* SamplingRateZ = Document->createElement(SamplingRateZXMLStr);
2723 DIGSampling* sampZ = &(header->SamplingZ);
2725 // set sampling rate Z attributes
2726 sprintf(valStr, "%f", sampZ->x);
2727 tmpXMLStr = XMLString::transcode(valStr);
2728 SamplingRateZ->setAttribute(DimmensionXXMLStr, tmpXMLStr);
2731 sprintf(valStr, "%f", sampZ->y);
2732 tmpXMLStr = XMLString::transcode(valStr);
2733 SamplingRateZ->setAttribute(DimmensionYXMLStr, tmpXMLStr);
2736 sprintf(valStr, "%f", sampZ->z);
2737 tmpXMLStr = XMLString::transcode(valStr);
2738 SamplingRateZ->setAttribute(DimmensionZXMLStr, tmpXMLStr);
2741 // append sampling rate Z to main header
2742 MainHeaderElement->appendChild(SamplingRateZ);
2745 // append main header to document root
2746 RootElement->appendChild(MainHeaderElement);
2749 if(MainHeaderWritten) {
2750 return -1; // main header already in file
2753 fprintf(File, " <main_header\n");
2754 fprintf(File, " type=\"%s\"\n", header->GetType());
2755 fprintf(File, " title=\"%s\"\n", header->GetTitle());
2756 fprintf(File, " channels=\"%d\"\n", header->GetChannels());
2757 fprintf(File, " number_of_arrays=\"%d\"\n", header->GetNumberOfArrays());
2758 fprintf(File, " number_of_array_sets=\"%d\"\n", header->GetNumberOfSets());
2759 fprintf(File, " endian=\"%s\"\n", header->GetEndianStr());
2760 fprintf(File, " value_type=\"%s\"\n", header->GetValueTypeStr());
2761 fprintf(File, " data_type=\"%s\"\n", header->GetDataTypeStr());
2762 fprintf(File, " data_format=\"%s\"\n", header->GetDataFormatStr());
2763 fprintf(File, " grid_type=\"%s\"\n", header->GetGridStr());
2764 fprintf(File, " basis_function=\"%s\"\n", header->GetBasisStr());
2765 fprintf(File, " unit=\"%s\"\n", header->GetUnitStr());
2768 if(header->GetOtherUnit() != NULL) {
2769 fprintf(File, " other_unit=\"%s\"\n", header->GetOtherUnit());
2772 fprintf(File, " >\n");
2774 if(header->GetComment() != NULL){
2775 fprintf (File, " <comments>\n");
2776 fprintf (File, " %s\n", header->GetComment());
2777 fprintf (File, " </comments>\n");
2780 DIGDimensions *dim = header->GetDimensions();
2781 fprintf(File, " <dimensions x=\"%d\" y=\"%d\" z=\"%d\"/>\n", dim->x, dim->y, dim->z);
2783 DIGSampling *sampX = header->GetSamplingX();
2784 fprintf(File, " <sampling_rate_x x=\"%6.3f\" y=\"%6.3f\" z=\"%6.3f\"/>\n", sampX->x, sampX->y, sampX->z);
2786 DIGSampling *sampY = header->GetSamplingY();
2787 fprintf(File, " <sampling_rate_y x=\"%6.3f\" y=\"%6.3f\" z=\"%6.3f\"/>\n", sampY->x, sampY->y, sampY->z);
2789 DIGSampling *sampZ = header->GetSamplingZ();
2790 fprintf(File, " <sampling_rate_z x=\"%6.3f\" y=\"%6.3f\" z=\"%6.3f\"/>\n", sampZ->x, sampZ->y, sampZ->z);
2792 fprintf(File, " </main_header>\n\n");
2793 //fprintf(File, " <!-- origin is %d %d %d -->\n", (dim->x-1)/2, (dim->y-1)/2, (dim->z-1)/2);
2796 MainHeaderWritten = true;
2801 int DIGFile::CreateApplicationHeader()
2804 #if DIGFILE_DEBUG_LEVEL > 2
\r
2805 fprintf(stderr, "DIGFile::CreateApplicationHeader\n");
\r
2813 int DIGFile::AppendArraySetHeader(DIGFileArraySetHeader* SetHeader)
2815 #if DIGFILE_DEBUG_LEVEL > 2
\r
2816 fprintf(stderr, "DIGFile::AppendArraySetHeader\n");
\r
2821 // create array set header node
2822 ArraySetHeaderElement = Document->createElement(ArraySetHeaderXMLStr);
2827 tmpXMLStr = XMLString::transcode(SetHeader->Type.Get());
2828 ArraySetHeaderElement->setAttribute(TypeXMLStr, tmpXMLStr);
2832 tmpXMLStr = XMLString::transcode(SetHeader->Title.Get());
2833 ArraySetHeaderElement->setAttribute(TitleXMLStr, tmpXMLStr);
2841 const char* Com = SetHeader->Comment.Get();
2845 // create comments node
2846 DOMElement* Comments = Document->createElement(CommentsXMLStr);
2848 // create comments text node
2849 tmpXMLStr = XMLString::transcode(Com);
2850 DOMText* CommentText = Document->createTextNode(tmpXMLStr);
2852 Comments->appendChild(CommentText);
2854 // append comments to array set header
2855 ArraySetHeaderElement->appendChild(Comments);
2858 // create parameters node
2859 DOMElement* Parameter = Document->createElement(ParametersXMLStr);
2861 // create parameters text node
2862 tmpXMLStr = XMLString::transcode(SetHeader->Parameters.Get());
2863 DOMText* ParameterText = Document->createTextNode(tmpXMLStr);
2865 Parameter->appendChild(ParameterText);
2867 // append parameters to array set header
2868 ArraySetHeaderElement->appendChild(Parameter);
2871 // append array set header to main header
2872 RootElement->appendChild(ArraySetHeaderElement);
2875 // check if main header written
2876 if(!MainHeaderWritten) {
2877 return -1; // error: no main header in file
2880 // close previous array set
2882 fprintf(File, " </array_set_header>\n\n");
2885 ArraySetOpen = true;
2887 // ArrayCounter = 0;
2889 fprintf(File, "\n <array_set_header\n");
2890 fprintf(File, " type=\"%s\"\n", SetHeader->GetType());
2891 fprintf(File, " title=\"%s\"\n", SetHeader->GetTitle());
2892 fprintf(File, " >\n");
2894 char* Comments = SetHeader->GetComments();
2896 if(Comments != NULL) {
2897 fprintf(File, " <comments>\n");
2898 fprintf(File, " %s\n", Comments);
2899 fprintf(File, " </comments>\n");
2902 fprintf(File, " <parameters>\n");
2903 fprintf(File, " %s\n", SetHeader->GetParameters());
2904 fprintf(File, " </parameters>\n");
2912 int DIGFile::AppendArrayHeader(DIGFileArrayHeader* ArrayHeader)
2914 #if DIGFILE_DEBUG_LEVEL > 2
\r
2915 fprintf(stderr, "DIGFile::AppendArrayHeader\n");
\r
2920 // create array set header node
2921 ArrayHeaderElement = Document->createElement(ArrayHeaderXMLStr);
2926 //tmpXMLStr = new XMLCh[5];
2927 //XMLString::binToText(ArrayHeader->EnumNo, tmpXMLStr, 4, 10);
2928 unsigned int maxchars = 1;
2929 if(ArrayHeader->EnumNo != 0) {
2930 maxchars += static_cast<unsigned int>(log10(static_cast<double>(ArrayHeader->EnumNo)));
\r
2932 tmpXMLStr = new XMLCh[maxchars+1];
2933 XMLString::binToText(ArrayHeader->EnumNo, tmpXMLStr, maxchars, 10);
2934 ArrayHeaderElement->setAttribute(EnumerationNumberXMLStr, tmpXMLStr);
2942 const char* Com = ArrayHeader->Comment.Get();
2946 // create comments node
2947 DOMElement* Comments = Document->createElement(CommentsXMLStr);
2949 // create comments text node
2950 tmpXMLStr = XMLString::transcode(Com);
2951 DOMText* CommentText = Document->createTextNode(tmpXMLStr);
2953 Comments->appendChild(CommentText);
2955 // append comments to array header
2956 ArrayHeaderElement->appendChild(Comments);
2960 // append array header to active array set header
2961 ArraySetHeaderElement->appendChild(ArrayHeaderElement);
2964 fprintf(File, "\n <array_header\n");
2966 //fprintf(File, " enumeration_number=\"%d\">\n", array_enumeration[sets*size+arrays]);
2967 //fprintf(File, " enumeration_number=\"%d\"\n", ArrayCounter);
2968 fprintf(File, " enumeration_number=\"%d\"\n", ArrayHeader->GetEnumeration());
2969 fprintf(File, " >\n");
2972 char* comment = ArrayHeader->GetComment();
2974 if(comment != NULL) {
2975 fprintf(File, " <comments>\n");
2976 fprintf(File, " %s\n", comment);
2977 fprintf(File, " </comments>\n");
2980 fprintf(File, " </array_header>\n");