include/DIGFile/DIGFile.h

   1 /*
   2
   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
  15
  16 */
  17
  18 // DIGFile.h,v 1.4 2007/06/07 20:48:35 jklukowska Exp
  19
  20
  21 //defines added to enable large file support
  22 //jklukowska, 06/07/2007
  23 #ifndef _LARGEFILE_SOURCE
  24         #define _LARGEFILE_SOURCE     /* enable large file support  */
  25 #endif
  26 #ifndef _FILE_OFFSET_BITS
  27         #define _FILE_OFFSET_BITS 64     /* enable large file support  */
  28 #endif
  29
  30
  31 #ifndef DIG_FILE_H
  32 #define DIG_FILE_H
  33
  34 #include <xercesc/dom/DOM.hpp>
  35 #include <xercesc/parsers/XercesDOMParser.hpp>
  36 #include <xercesc/util/PlatformUtils.hpp>
  37
  38 //#include <DIG.h>
  39 #include <DIGFile/DIG.h>
  40 //#include "DOMTreeErrorReporter.h"
  41 #include <DIGFile/DOMTreeErrorReporter.h>
  42
  43 #include <xercesc/framework/MemBufInputSource.hpp>
  44
  45 enum DIGEndian {
  46   DIGEndian_LITTLE,
  47   DIGEndian_BIG
  48 };
  49
  50 #define DIGEndianSize 2
  51 extern const char* DIGEndianStr[DIGEndianSize];
  52
  53
  54 enum DIGValueType {
  55   DIGValueType_REAL,
  56   DIGValueType_COMPLEX
  57 };
  58
  59 #define DIGValueTypeSize 2
  60 extern const char* DIGValueTypeStr[DIGValueTypeSize];
  61
  62
  63 enum DIGDataType {
  64   DIGDataType_BOOL,
  65   DIGDataType_UCHAR,
  66   DIGDataType_CHAR,
  67   DIGDataType_USHORT,
  68   DIGDataType_SHORT,
  69   DIGDataType_UINT,
  70   DIGDataType_INT,
  71   DIGDataType_FLOAT,
  72   DIGDataType_DOUBLE
  73 };
  74
  75 #define DIGDataTypeSize 9
  76 extern const char* DIGDataTypeStr[DIGDataTypeSize];
  77
  78
  79 enum DIGDataFormat {
  80   DIGDataFormat_ASCII,
  81   DIGDataFormat_BINARY
  82 };
  83
  84 #define DIGDataFormatSize 2
  85 extern const char* DIGDataFormatStr[DIGDataFormatSize];
  86
  87
  88 enum DIGGrid {
  89   DIGGrid_SC,
  90   DIGGrid_FCC1,
  91   DIGGrid_FCC2,
  92   DIGGrid_BCC1,
  93   DIGGrid_BCC2,
  94   DIGGrid_BCC3,
  95   DIGGrid_BCC4,
  96   DIGGrid_HEX1,
  97   DIGGrid_HEX2
  98 };
  99
 100 #define DIGGridSize 9
 101 extern const char* DIGGridStr[DIGGridSize];
 102
 103
 104 enum DIGBasis {
 105   DIGBasis_VORONOI,
 106   DIGBasis_BLOB
 107 };
 108
 109 #define DIGBasisSize 2
 110 extern const char* DIGBasisStr[DIGBasisSize];
 111
 112
 113 enum DIGUnit {
 114   DIGUnit_UNSPECIFIED,
 115   DIGUnit_m,
 116   DIGUnit_cm,
 117   DIGUnit_mm,
 118   DIGUnit_nm,
 119   DIGUnit_micron,
 120   DIGUnit_A,
 121   DIGUnit_OTHER
 122 };
 123
 124 #define DIGUnitSize 8
 125 extern const char* DIGUnitStr[DIGUnitSize];
 126
 127
 128 struct DIGDimensions {
 129         int x;
 130         int y;
 131         int z;
 132 };
 133
 134 struct DIGSampling {
 135         double x;
 136         double y;
 137         double z;
 138 };
 139
 140 ///////////////////////////////////////////////////////////////////////////////
 141 // DIGFile array set header
 142 ///////////////////////////////////////////////////////////////////////////////
 143
 144 class DIGFileMainHeader
 145 {
 146 public:
 147         DIGString       Type;
 148         DIGString       Title;
 149         unsigned int    Channels;
 150         //unsigned int    NoOfArrays;
 151         //unsigned int    NoOfSets;
 152         //DIGEndian       Endian;
 153         DIGValueType    ValueType;
 154         DIGDataType     DataType;
 155         DIGDataFormat   DataFormat;
 156         DIGGrid         Grid;
 157         DIGBasis        Basis;
 158         DIGUnit         Unit;
 159         DIGString       OtherUnit;
 160         DIGDimensions   Dimensions;
 161         DIGSampling     SamplingX;
 162         DIGSampling     SamplingY;
 163         DIGSampling     SamplingZ;
 164         DIGString       Comment;
 165
 166 public:
 167   DIGFileMainHeader()
 168   {
 169     // set defaults
 170           Channels = 1;
 171           //NoOfArrays = 0;
 172           //NoOfSets = 0;
 173           //Endian = DIGEndian_LITTLE;
 174           ValueType = DIGValueType_REAL;
 175           DataType = DIGDataType_DOUBLE;
 176           DataFormat = DIGDataFormat_ASCII;
 177           Grid = DIGGrid_SC;
 178           Basis = DIGBasis_VORONOI;
 179           Unit = DIGUnit_UNSPECIFIED;
 180           Dimensions.x = 1;
 181           Dimensions.y = 1;
 182           Dimensions.z = 0;
 183           SamplingX.x = 1;
 184           SamplingX.y = 0;
 185           SamplingX.z = 0;
 186           SamplingY.x = 0;
 187           SamplingY.y = 1;
 188           SamplingY.z = 0;
 189           SamplingZ.x = 0;
 190           SamplingZ.y = 0;
 191           SamplingZ.z = 1;
 192   };
 193
 194   DIGFileMainHeader(
 195           const char*   pType,
 196           const char*   pTitle,
 197     unsigned int  pChannels,
 198     //unsigned int  pArrays,
 199     //unsigned int  pSets,
 200     //DIGEndian     pEndian,
 201     DIGValueType  pValueType,
 202     DIGDataType   pDataType,
 203     DIGDataFormat pDataFormat,
 204     DIGGrid       pGrid,
 205     DIGBasis      pBasis,
 206     DIGUnit       pUnit,
 207     DIGDimensions pDim,
 208     DIGSampling   pSampX,
 209     DIGSampling   pSampY,
 210     DIGSampling   pSampZ,
 211     const char*   pComment,
 212     const char*   pOtherUnit
 213   )
 214   {
 215     Type.Set(pType);
 216     Title.Set(pTitle);
 217           Channels = pChannels;
 218           //NoOfArrays = pArrays;
 219           //NoOfSets = pSets;
 220           //Endian = pEndian;
 221           ValueType = pValueType;
 222           DataType = pDataType;
 223           DataFormat = pDataFormat;
 224           Grid = pGrid;
 225           Basis = pBasis;
 226           Unit = pUnit;
 227           OtherUnit.Set(pOtherUnit);
 228           Dimensions = pDim;
 229           SamplingX = pSampX;
 230           SamplingY = pSampY;
 231           SamplingZ = pSampZ;
 232     Comment.Set(pComment);
 233   };
 234 };
 235
 236 ///////////////////////////////////////////////////////////////////////////////
 237 // DIGFile array set header
 238 ///////////////////////////////////////////////////////////////////////////////
 239
 240 class DIGFileArraySetHeader
 241 {
 242 public:
 243
 244         DIGString Type;
 245         DIGString Title;
 246         DIGString Parameters;
 247   DIGString Comment;
 248
 249   DIGFileArraySetHeader() {};
 250   DIGFileArraySetHeader(const char* pType, const char* pTitle, const char* pParameters, const char* pComments = NULL)
 251   {
 252           Type.Set(pType);
 253           Title.Set(pTitle);
 254           Parameters.Set(pParameters);
 255     Comment.Set(pComments);
 256   };
 257 };
 258
 259 ///////////////////////////////////////////////////////////////////////////////
 260 // DIGFile array header
 261 ///////////////////////////////////////////////////////////////////////////////
 262
 263 class DIGFileArrayHeader {
 264
 265 public:
 266         unsigned int EnumNo;
 267   DIGString    Comment;
 268
 269   DIGFileArrayHeader() {};
 270   DIGFileArrayHeader(unsigned int pEnumNo, const char* pComment) {
 271     EnumNo = pEnumNo;
 272     Comment.Set(pComment);
 273   };
 274 };
 275
 276
 277
 278 class ListElement
 279 {
 280 public:
 281   void* Item;
 282   ListElement* NextListElement;
 283
 284   inline ListElement(void* It)
 285   {
 286     Item = It;
 287     NextListElement = NULL;
 288   }
 289 };
 290
 291 class List
 292 {
 293 private:
 294   ListElement*  Head;
 295
 296 protected:
 297   unsigned int  Length;
 298
 299 public:
 300   List() {
 301     Head = NULL;
 302     Length = 0;
 303   }
 304
 305   inline unsigned int getLength() {
 306     return Length;
 307   }
 308
 309   inline void Append(ListElement* LElement) {
 310     ListElement** ListElementPtr = &Head;
 311     while((*ListElementPtr) != NULL) {
 312       ListElementPtr = &((*ListElementPtr)->NextListElement);
 313     }
 314     *ListElementPtr = LElement;
 315     Length++;
 316   }
 317
 318   inline int getListElement(ListElement** ListElementPtr, unsigned int index) {
 319
 320     *ListElementPtr = Head;
 321     if((*ListElementPtr) == NULL) {
 322       return -1;  // error empty list
 323     }
 324
 325     for(unsigned int i = 0; i < index; i++) {
 326       *ListElementPtr = (*ListElementPtr)->NextListElement;
 327       if((*ListElementPtr) == NULL) {
 328         return -1;  // error
 329       }
 330     }
 331     return 0;
 332   }
 333
 334   inline int removeListElement(ListElement** ListElementPtr, unsigned int index) {
 335
 336     *ListElementPtr = Head;
 337     if((*ListElementPtr) == NULL) {
 338       return -1;  // error empty list
 339     }
 340
 341     // first element of the list
 342     ListElement** prevPtr = &Head;
 343
 344     for(unsigned int i = 0; i < index; i++) {
 345
 346       prevPtr = &((*ListElementPtr)->NextListElement);
 347       *ListElementPtr = (*ListElementPtr)->NextListElement;
 348       if((*ListElementPtr) == NULL) {
 349         return -1;  // error
 350       }
 351     }
 352
 353     *prevPtr = (*ListElementPtr)->NextListElement;
 354     (*ListElementPtr)->NextListElement = NULL;
 355     Length--;
 356     return 0;
 357   }
 358 };
 359
 360 class PointerList: private List
 361 {
 362
 363 public:
 364 /*
 365   List() {
 366     Head = NULL;
 367     Length = 0;
 368   }
 369   */
 370
 371   inline unsigned int getLength() {
 372     return Length;
 373   }
 374
 375   inline void Append(void* Pointer) {
 376     ListElement* LI = new ListElement(Pointer);
 377     List::Append(LI);
 378   }
 379
 380   inline int getListElement(void** Pointer, unsigned int index) {
 381
 382     ListElement* LI;
 383     if(List::getListElement(&LI, index) != 0) {
 384       return -1; // error
 385     }
 386     *Pointer = LI->Item;
 387     return 0;
 388   }
 389
 390   inline int removeListElement(void** Pointer, unsigned int index) {
 391
 392     ListElement* LI;
 393
 394     if(List::removeListElement(&LI, index) != 0) {
 395       return -1; // error
 396     }
 397
 398     *Pointer = LI->Item;
 399     delete LI;
 400     return 0;
 401   }
 402 };
 403
 404
 405 class ArraySet
 406 {
 407 private:
 408   PointerList            ArrayHeaderList;  // list of array heders in the set
 409
 410 public:
 411   unsigned int           FirstArrayOffset; // offset of first array in the set
 412   DIGFileArraySetHeader* ArraySetHeader;
 413
 414
 415   inline unsigned int getLength() {
 416     return ArrayHeaderList.getLength();
 417   }
 418
 419   inline void Append(DIGFileArrayHeader* ArrayHeader) {
 420     ArrayHeaderList.Append(ArrayHeader);
 421   }
 422
 423   inline int getArrayHeader(DIGFileArrayHeader** ArrayHeader, unsigned int index) {
 424     return ArrayHeaderList.getListElement((void**) ArrayHeader, index);
 425   }
 426
 427   inline int removeArrayHeader(DIGFileArrayHeader** ArrayHeader, unsigned int index) {
 428     return ArrayHeaderList.removeListElement((void**) ArrayHeader, index);
 429   }
 430
 431   inline int Release() {
 432     DIGFileArrayHeader* ArrayHeader;
 433
 434     int Lenght = getLength();
 435     for(int i = 0; i < Lenght; i++) {
 436       // remove first item from the list
 437       if(removeArrayHeader(&ArrayHeader, 0) != 0) {
 438         return -1; // error
 439       }
 440       delete ArrayHeader;
 441     }
 442     return 0;
 443   }
 444 };
 445
 446
 447 class ArraySetList
 448 {
 449   PointerList            ASList;
 450
 451 public:
 452
 453   inline unsigned int getLength() {
 454     return ASList.getLength();
 455   }
 456
 457   inline void Append(ArraySet* ASet) {
 458     ASList.Append(ASet);
 459   }
 460
 461   inline int getArraySet(ArraySet** ASet, unsigned int index) {
 462     return ASList.getListElement((void**) ASet, index);
 463   }
 464
 465   inline int removeArraySet(ArraySet** ASet, unsigned int index) {
 466     return ASList.removeListElement((void**) ASet, index);
 467   }
 468
 469   inline int Release() {
 470     ArraySet* ASet;
 471
 472     int Lenght = getLength();
 473     for(int i = 0; i < Lenght; i++) {
 474       // remove first item from the list
 475       if(removeArraySet(&ASet, 0) != 0) {
 476         return -1; // error
 477       }
 478       ASet->Release();
 479     }
 480     return 0;
 481   }
 482 };
 483
 484 class DIGFile
 485 {
 486 protected:
 487
 488   // File Variables
 489   DIGString           SchemaName;         // XML schema name
 490   DIGFileMainHeader   MainHeader;         // main header
 491
 492   unsigned int        NoOfSets;
 493   unsigned int        NoOfArrays;
 494   DIGEndian           Endian;             // File Endian
 495
 496   FILE*               File;
 497   FILE*               TmpDataFile;
 498
 499   int                   XMLHeaderLength;
 500   bool                  MainHeaderWritten;
 501   bool                  Dirty;
 502
 503   ArraySetList          ArraySets;        // array sets list
 504
 505   unsigned int          NoOfArrayItems;   // number of items in array
 506   unsigned int          ArrayBufferSize;  // array buffer size
 507
 508   // Curent Array Set Variables
 509   ArraySet*             CurrenArraySet;
 510
 511   // Cureny Array Variables
 512   DIGFileArrayHeader*   CurrentArrayHeader;
 513   int          CurrenArrayIndex; // index of curent array
 514
 515
 516   // XML Parsing and Writing
 517
 518   bool                  ArraySetOpen;
 519   //int                   ArrayCounter;     // arrays counter
 520
 521   // DOM
 522
 523   XercesDOMParser*      parser;
 524   DOMTreeErrorReporter* errReporter;
 525
 526   DOMImplementation* impl;
 527
 528   DOMDocument* Document;
 529   DOMElement*  RootElement;
 530   DOMElement*  MainHeaderElement;
 531   DOMElement*  ApplicationHeaderElement;
 532   DOMElement*  ArraySetHeaderElement;     // active array set header
 533   DOMElement*  ArrayHeaderElement;        // active array header
 534
 535   DOMNodeList* ArraySetHeaderList;
 536   DOMNodeList* ArrayHeaderList;
 537
 538
 539   // XML Strings
 540   static bool XMLStringsInitialized;
 541
 542
 543   static const XMLCh* RootXMLStr;
 544
 545   static const XMLCh* MainHeaderXMLStr;
 546
 547   static const XMLCh* TitleXMLStr;
 548   static const XMLCh* TypeXMLStr;
 549   static const XMLCh* ChannelsXMLStr;
 550   static const XMLCh* NumberOfArraysXMLStr;
 551   static const XMLCh* NumberOfArraySetsXMLStr;
 552   static const XMLCh* EndianXMLStr;
 553   static const XMLCh* ValueTypeXMLStr;
 554   static const XMLCh* DataTypeXMLStr;
 555   static const XMLCh* DataFormatXMLStr;
 556   static const XMLCh* GridTypeXMLStr;
 557   static const XMLCh* BasisFunctionXMLStr;
 558   static const XMLCh* UnitXMLStr;
 559   static const XMLCh* OtherUnitXMLStr;
 560   static const XMLCh* CommentsXMLStr;
 561   static const XMLCh* DimensionsXMLStr;
 562
 563   static const XMLCh* DimmensionXXMLStr;
 564   static const XMLCh* DimmensionYXMLStr;
 565   static const XMLCh* DimmensionZXMLStr;
 566
 567   static const XMLCh* SamplingRateXXMLStr;
 568   static const XMLCh* SamplingRateYXMLStr;
 569   static const XMLCh* SamplingRateZXMLStr;
 570
 571   static const XMLCh* ArraySetHeaderXMLStr;
 572
 573   //static const XMLCh* TypeXMLStr;
 574   //static const XMLCh* TitleXMLStr;
 575   static const XMLCh* ParametersXMLStr;
 576
 577   static const XMLCh* ArrayHeaderXMLStr;
 578   static const XMLCh* EnumerationNumberXMLStr;
 579
 580 public:
 581   DIGFile();
 582   virtual ~DIGFile() { };
 583
 584   int Open(const char* FileName);
 585   int Open(
 586     const char*           pFileName,
 587     const char*           pSchema,
 588           const char*           pTitle,
 589           const char*           pType,
 590           unsigned int          pChannels,
 591           //DIGEndian             pEndian,
 592           DIGValueType          pValueType,
 593           DIGDataType           pDataType,
 594           DIGDataFormat         pDataFormat,
 595           DIGGrid               pGrid,
 596           DIGBasis              pBasis,
 597           DIGUnit               pUnit,
 598           const DIGDimensions*  pDimensions,
 599           const DIGSampling*    pSamplingX,
 600           const DIGSampling*    pSamplingY,
 601           const DIGSampling*    pSamplingZ,
 602           const char*           pComment,
 603           const char*           pOtherUnit
 604   );
 605
 606   int Close();
 607
 608   int GetArrayBufferSize(unsigned int* pArrayBufferSize);
 609   int GetArrayNoOfItems(unsigned int* pArrayNoOfItems);
 610   int GetNoOfArraySets(unsigned int* pNoOfArraySets);
 611   int GetNoOfArrays(unsigned int* pNoOfArrays);
 612
 613   // main header
 614   int SetComment(const char* pComment);
 615   int SetTitle(const char* pTitle);
 616
 617   int GetTitle(const char** pTitle);
 618   int GetType(const char** pType);
 619   int GetChannels(unsigned int* pChannels);
 620   int GetEndian(DIGEndian* pEndian);
 621   int GetValueType(DIGValueType* pValueType);
 622   int GetDataType(DIGDataType* pDataType);
 623   int GetDataFormat(DIGDataFormat* pDataFormat);
 624   int GetGrid(DIGGrid* pGrid);
 625   int GetBasis(DIGBasis* pBasis);
 626   int GetUnit(DIGUnit* pUnit);
 627   int GetOtherUnit(const char** pOtherUnit);
 628   int GetDimensions(const DIGDimensions** pDimensions);
 629   int GetSamplingX(const DIGSampling** pSampling);
 630   int GetSamplingY(const DIGSampling** pSampling);
 631   int GetSamplingZ(const DIGSampling** pSampling);
 632   int GetComment(const char** pComment);
 633
 634
 635   //int AppendArraySet(DIGFileArraySetHeader* SetHeader);
 636   int AppendArraySet(
 637     const char* pType,
 638     const char* pTitle,
 639     const char* pParameters,
 640     const char* pComments
 641   );
 642
 643    //int AppendArray(DIGFileArrayHeader* ArrayHeader, void* Buffer);
 644   int AppendArray(
 645     unsigned int pEnumerationNumber,
 646     const char* pComment,
 647     const void* pBuffer
 648   );
 649
 650   //int GetArraySetHeader(DIGFileArraySetHeader** SetHeader);
 651   int GetArraySetType(const char** pType);
 652   int GetArraySetTitle(const char** pTitle);
 653   int GetArraySetParameters(const char** pParameters);
 654   int GetArraySetComment(const char** pComments);
 655
 656   //int GetArrayHeader(DIGFileArrayHeader** ArrayHeader);
 657   int GetArrayEnumNo(unsigned int* pEnumNo);
 658   int GetArrayComment(const char** pComment);
 659
 660
 661   int SelectArraySet(unsigned int pNo);
 662   int SelectArray(unsigned int pNo);
 663
 664   int GetArrayData(void* pArrayData);
 665
 666 protected:
 667
 668   unsigned int ComputeArrayNoOfItems();
 669   unsigned int ComputeArrayBufferSize();
 670
 671   int SymbolToCode(char* Symbol, const char** SymbolTable, int NumberOfSymbols);
 672
 673   int WriteArrayData(FILE* f, const void* ArrayData);
 674
 675   int FindSrting(char* String, FILE* File);
 676   int GetXMLHeader(char** XMLBuff);
 677
 678   // Writing Methods
 679   int WriteXMLHeader();
 680   void CreateRootElement();
 681   virtual int CreateApplicationHeader();
 682   int CreateMainHeader(DIGFileMainHeader* header);
 683   int AppendArraySetHeader(DIGFileArraySetHeader* SetHeader);
 684   int AppendArrayHeader(DIGFileArrayHeader* ArrayHeader);
 685
 686
 687   // Reading Methods
 688   int InitParser2(const MemBufInputSource& memBufIS);
 689   int ResetParser();
 690   int GetIntAttributeValue(DOMElement* Element, const XMLCh* AttributeName, int* value);
 691   int GetUintAttributeValue(DOMElement* Element, const XMLCh* AttributeName, unsigned int* value);
 692   int GetDoubleAttributeValue(DOMElement* Element, const XMLCh* AttributeName, double* value);
 693   int GetTxtAttributeValue(DOMElement* Element, const XMLCh* AttributeName, char** Text);
 694   int GetElementText(DOMElement* Element, char** Text);
 695
 696   int GetMainHeader(DIGFileMainHeader* MainHeader);
 697   virtual int ParseApplicationHeader();
 698   int GetArraySetHeader(DIGFileArraySetHeader* ArraySetHeader, unsigned int index);
 699   int GetArrayHeader(DIGFileArrayHeader* ArrayHeader, unsigned int index);
 700
 701   int ParseXML(const char* MemBuf);
 702
 703   int CreateMainHeader();
 704 };
 705
 706 #endif