libctsim/array2dfile.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **      Name:         array2dfile.cpp
   5 **      Purpose:      2-dimension array file class
   6 **      Programmer:   Kevin Rosenberg
   7 **      Date Started: June 2000
   8 **
   9 **  This is part of the CTSim program
  10 **  Copyright (C) 1983-2000 Kevin Rosenberg
  11 **
  12 **  $Id: array2dfile.cpp,v 1.23 2001/01/01 10:14:34 kevin Exp $
  13 **
  14 **  This program is free software; you can redistribute it and/or modify
  15 **  it under the terms of the GNU General Public License (version 2) as
  16 **  published by the Free Software Foundation.
  17 **
  18 **  This program is distributed in the hope that it will be useful,
  19 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 **  GNU General Public License for more details.
  22 **
  23 **  You should have received a copy of the GNU General Public License
  24 **  along with this program; if not, write to the Free Software
  25 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 ******************************************************************************/
  27
  28 #include "array2dfile.h"
  29 #include <ctime>\r
  30 #ifdef MSVC\r
  31 typedef long off_t;\r
  32 #endif
  33
  34
  35 const kuint16 Array2dFile::m_signature = ('I'*256+'F');
  36
  37 ///////////////////////////////////////////////////////////////////////////
  38 // CLASS IMPLEMENTATION
  39 //
  40 //     Name: Array2dFileLabel
  41 //     Purpose: Labels for Array2dFiles
  42 ///////////////////////////////////////////////////////////////////////////
  43
  44 void
  45 Array2dFileLabel::init (void)
  46 {
  47   m_calcTime = 0;
  48   m_labelType = L_EMPTY;
  49   time_t t = time(0);
  50   tm* lt = localtime(&t);
  51   m_year = lt->tm_year;
  52   m_month = lt->tm_mon;
  53   m_day = lt->tm_mday;
  54   m_hour = lt->tm_hour;
  55   m_minute = lt->tm_min;
  56   m_second = lt->tm_sec;
  57 }
  58
  59 Array2dFileLabel::Array2dFileLabel()
  60 {
  61   init();
  62 }
  63
  64 Array2dFileLabel::Array2dFileLabel(const char* const str, double ctime)
  65 : m_strLabel (str)
  66 {
  67   init();
  68
  69   m_labelType = L_USER;
  70   m_calcTime = ctime;
  71 }
  72
  73 Array2dFileLabel::Array2dFileLabel(const int type, const char* const str, double ctime)
  74 :  m_strLabel (str)
  75 {
  76   init();
  77
  78   m_labelType = type;
  79   m_calcTime = ctime;
  80 }
  81
  82 Array2dFileLabel::~Array2dFileLabel()
  83 {
  84 }
  85
  86 void
  87 Array2dFileLabel::setDateTime (int year, int month, int day, int hour, int minute, int second)
  88 {
  89   m_year = year;
  90   m_month = month;
  91   m_day = day;
  92   m_hour = hour;
  93   m_minute = minute;
  94   m_second = second;
  95 }
  96
  97 void
  98 Array2dFileLabel::getDateTime (int& year, int& month, int& day, int& hour, int& minute, int& second) const
  99 {
 100   year = m_year;
 101   month = m_month;
 102   day = m_day;
 103   hour = m_hour;
 104   minute = m_minute;
 105   second = m_second;
 106 }
 107
 108 const std::string&
 109 Array2dFileLabel::getDateString (void) const
 110 {
 111   char szDate [128];\r
 112   snprintf (szDate, sizeof(szDate), "%2d/%02d/%4d %02d:%02d:%02d",\r
 113     m_month + 1, m_day, m_year + 1900, m_hour, m_minute, m_second);
 114   m_strDate = szDate;
 115   return m_strDate;
 116 }
 117
 118
 119 Array2dFileLabel::Array2dFileLabel (const Array2dFileLabel& rhs)
 120 {
 121   m_calcTime = rhs.m_calcTime;
 122   m_labelType = rhs.m_labelType;
 123   m_strLabel = rhs.m_strLabel;
 124   m_year = rhs.m_year; m_month = rhs.m_month; m_day = rhs.m_day;
 125   m_hour = rhs.m_hour; m_minute = rhs.m_minute; m_second = rhs.m_second;
 126 }
 127
 128 Array2dFileLabel&
 129 Array2dFileLabel::operator= (const Array2dFileLabel& rhs)
 130 {
 131   m_calcTime = rhs.m_calcTime;
 132   m_labelType = rhs.m_labelType;
 133   m_strLabel = rhs.m_strLabel;
 134   m_year = rhs.m_year; m_month = rhs.m_month; m_day = rhs.m_day;
 135   m_hour = rhs.m_hour; m_minute = rhs.m_minute; m_second = rhs.m_second;
 136
 137   return (*this);
 138 }
 139
 140 void
 141 Array2dFileLabel::print (std::ostream& os) const
 142 {
 143   if (m_labelType == L_HISTORY) {
 144     os << "History: " << std::endl;
 145     os << "  " << m_strLabel << std::endl;
 146     os << "  calc time = " << m_calcTime << " secs" << std::endl;
 147     os << "  Timestamp = " << getDateString() << std::endl;
 148   } else if (m_labelType == L_USER) {
 149     os << "Note: " <<  m_strLabel << std::endl;
 150     os << "  Timestamp = %s" << getDateString() << std::endl;
 151   } else {
 152     os << "Unknown (" << m_labelType << "): " <<  m_strLabel << std::endl;
 153     os << "  Timestamp = %s" << getDateString() << std::endl;
 154   }
 155 }
 156
 157
 158 ///////////////////////////////////////////////////////////////////////////
 159 // CLASS IMPLEMENTATION
 160 //
 161 //     Name: Array2dFile
 162 //     Purpose: Array2dFiles
 163 ///////////////////////////////////////////////////////////////////////////
 164
 165
 166 Array2dFile::Array2dFile (int x, int y, int pixelSize, int pixelFormat, int dataType)
 167 {
 168   init();
 169   setArraySize (x, y, pixelSize, pixelFormat, dataType);
 170 }
 171
 172 Array2dFile::~Array2dFile (void)
 173 {
 174   freeArrays ();
 175   for (labelIterator l = m_labels.begin(); l != m_labels.end(); l++)
 176     delete *l;
 177 }
 178
 179 Array2dFile::Array2dFile (void)
 180 {
 181   init();
 182 }
 183
 184 void
 185 Array2dFile::init (void)
 186 {
 187   m_pixelSize = 0;
 188   m_pixelFormat = PIXEL_INVALID;
 189   m_arrayData = NULL;\r
 190   m_imaginaryArrayData = NULL;\r
 191   m_dataType = DATA_TYPE_INVALID;
 192   m_nx = 0;
 193   m_ny = 0;
 194   m_headersize = 0;
 195   m_axisIncrementKnown = false;
 196   m_axisIncrementX = m_axisIncrementY = 0;
 197   m_axisExtentKnown = false;
 198   m_minX = m_maxX = m_minY = m_maxY = 0;
 199   m_offsetPV = 0;
 200   m_scalePV = 1;
 201 }
 202
 203
 204 void
 205 Array2dFile::setArraySize (int x, int y, int pixelSize, int pixelFormat, int dataType)
 206 {
 207   m_pixelSize = pixelSize;
 208   m_pixelFormat = pixelFormat;\r
 209   m_dataType = dataType;
 210   setArraySize (x, y);
 211 }
 212
 213 void
 214 Array2dFile::setArraySize (int x, int y)
 215 {
 216   m_nx = x;
 217   m_ny = y;
 218   allocArrays ();
 219 }\r
 220 \r
 221 bool\r
 222 Array2dFile::reallocComplexToReal ()\r
 223 {\r
 224   if (m_dataType != DATA_TYPE_COMPLEX)\r
 225     return false;\r
 226 \r
 227   freeArray (m_imaginaryArrayData);\r
 228   m_dataType = DATA_TYPE_REAL;\r
 229 \r
 230   return true;\r
 231 }\r
 232 \r
 233 \r
 234 bool\r
 235 Array2dFile::reallocRealToComplex ()\r
 236 {\r
 237   if (m_dataType != DATA_TYPE_REAL)\r
 238     return false;\r
 239 \r
 240   allocArray (m_imaginaryArrayData);\r
 241   m_dataType = DATA_TYPE_COMPLEX;\r
 242 \r
 243   return true;\r
 244 }\r
 245 \r
 246
 247
 248 void
 249 Array2dFile::allocArrays ()
 250 {
 251   if (m_arrayData) \r
 252     freeArray (m_arrayData);\r
 253   if (m_imaginaryArrayData)\r
 254     freeArray (m_imaginaryArrayData);\r
 255 \r
 256   allocArray (m_arrayData);\r
 257   if (m_dataType == DATA_TYPE_COMPLEX)\r
 258     allocArray (m_imaginaryArrayData);\r
 259 }\r
 260 \r
 261 void\r
 262 Array2dFile::allocArray (unsigned char**& rppData)\r
 263 {\r
 264   m_arraySize = m_nx * m_ny * m_pixelSize;
 265   rppData = new unsigned char* [m_nx];\r
 266   int columnBytes = m_ny * m_pixelSize;
 267   for (unsigned int i = 0; i < m_nx; i++)
 268     rppData[i] = new unsigned char [columnBytes];\r
 269 }
 270
 271 void
 272 Array2dFile::freeArrays ()
 273 {
 274   if (m_arrayData) \r
 275     freeArray (m_arrayData);\r
 276   \r
 277   if (m_imaginaryArrayData) \r
 278     freeArray (m_imaginaryArrayData);\r
 279   \r
 280 }\r
 281 \r
 282 void\r
 283 Array2dFile::freeArray (unsigned char**& rppData)\r
 284 {\r
 285    for (unsigned int i = 0; i < m_nx; i++)\r
 286       delete rppData[i];\r
 287     delete rppData;\r
 288     rppData = NULL;\r
 289 }\r
 290 \r
 291
 292 bool
 293 Array2dFile::fileWrite (const std::string& filename)
 294 {
 295   return fileWrite (filename.c_str());
 296 }
 297
 298 bool
 299 Array2dFile::fileWrite (const char* const filename)
 300 {
 301   m_filename = filename;
 302
 303   frnetorderstream fs (m_filename.c_str(), std::ios::out | std::ios::in | std::ios::trunc | std::ios::binary);
 304   if (fs.fail()) {
 305     sys_error (ERR_WARNING, "Error opening file %s for writing [fileCreate]", m_filename.c_str());
 306     return false;
 307   }
 308   if (! headerWrite(fs))
 309     return false;
 310
 311   if (! arrayDataWrite (fs))
 312     return false;
 313
 314   if (! labelsWrite (fs))
 315     return false;
 316
 317   return true;
 318 }
 319
 320 bool
 321 Array2dFile::fileRead (const std::string& filename)
 322 {
 323   return fileRead (filename.c_str());
 324 }
 325
 326 bool
 327 Array2dFile::fileRead (const char* const filename)
 328 {
 329   m_filename = filename;
 330
 331 #ifdef MSVC\r
 332   frnetorderstream fs (m_filename.c_str(), std::ios::out | std::ios::in | std::ios::binary);\r
 333 #else\r
 334   frnetorderstream fs (m_filename.c_str(), std::ios::out | std::ios::in | std::ios::binary | std::ios::nocreate);\r
 335 #endif\r
 336   if (fs.fail()) {
 337     sys_error (ERR_WARNING, "Unable to open file %s [fileRead]", m_filename.c_str());
 338     return false;
 339   }
 340
 341   if (! headerRead(fs))
 342     return false;
 343
 344   allocArrays ();
 345
 346   if (! arrayDataRead(fs))
 347     return false;;
 348
 349   if (! labelsRead (fs))
 350     return false;
 351
 352   return true;
 353 }
 354
 355 void
 356 Array2dFile::setAxisIncrement (double incX, double incY)
 357 {
 358   m_axisIncrementKnown = true;
 359   m_axisIncrementX = incX;
 360   m_axisIncrementY = incY;
 361 }
 362
 363 void
 364 Array2dFile::setAxisExtent (double minX, double maxX, double minY, double maxY)
 365 {
 366   m_axisExtentKnown = true;
 367   m_minX = minX;
 368   m_maxY = maxX;
 369   m_minX = minX;
 370   m_maxY = maxY;
 371 }
 372
 373 bool
 374 Array2dFile::headerRead (frnetorderstream& fs)
 375 {
 376   if (! fs) {
 377     sys_error (ERR_WARNING, "Tried to read header with file closed [headerRead]");
 378     return false;
 379   }
 380
 381   fs.seekg (0);
 382   kuint16 file_signature;
 383
 384   fs.readInt16 (m_headersize);
 385   fs.readInt16 (file_signature);
 386   fs.readInt16 (m_pixelFormat);
 387   fs.readInt16 (m_pixelSize);
 388   fs.readInt16 (m_numFileLabels);
 389   fs.readInt32 (m_nx);
 390   fs.readInt32 (m_ny);\r
 391   fs.readInt16 (m_dataType);
 392   fs.readInt16 (m_axisIncrementKnown);
 393   fs.readFloat64 (m_axisIncrementX);
 394   fs.readFloat64 (m_axisIncrementY);
 395   fs.readInt16 (m_axisExtentKnown);
 396   fs.readFloat64 (m_minX);
 397   fs.readFloat64 (m_maxX);
 398   fs.readFloat64 (m_minY);
 399   fs.readFloat64 (m_maxY);
 400   fs.readFloat64 (m_offsetPV);
 401   fs.readFloat64 (m_scalePV);
 402
 403   int read_m_headersize = fs.tellg();
 404   if (read_m_headersize != m_headersize) {
 405     sys_error (ERR_WARNING, "Read m_headersize %d != file m_headersize %d", read_m_headersize, m_headersize);
 406     return false;
 407   }
 408   if (file_signature != m_signature) {
 409     sys_error (ERR_WARNING, "File signature %d != true signature %d", file_signature, m_signature);
 410     return false;
 411   }
 412
 413   return ! fs.fail();
 414 }
 415
 416
 417 bool
 418 Array2dFile::headerWrite (frnetorderstream& fs)
 419 {
 420   if (! fs) {
 421     sys_error (ERR_WARNING, "Tried to write header with ! fs");
 422     return false;
 423   }
 424
 425   m_numFileLabels = m_labels.size();
 426
 427   fs.seekp (0);
 428   fs.writeInt16 (m_headersize);
 429   fs.writeInt16 (m_signature);
 430   fs.writeInt16 (m_pixelFormat);
 431   fs.writeInt16 (m_pixelSize);
 432   fs.writeInt16 (m_numFileLabels);
 433   fs.writeInt32 (m_nx);
 434   fs.writeInt32 (m_ny);\r
 435   fs.writeInt16 (m_dataType);
 436   fs.writeInt16 (m_axisIncrementKnown);
 437   fs.writeFloat64 (m_axisIncrementX);
 438   fs.writeFloat64 (m_axisIncrementY);
 439   fs.writeInt16 (m_axisExtentKnown);
 440   fs.writeFloat64 (m_minX);
 441   fs.writeFloat64 (m_maxX);
 442   fs.writeFloat64 (m_minY);
 443   fs.writeFloat64 (m_maxY);
 444   fs.writeFloat64 (m_offsetPV);
 445   fs.writeFloat64 (m_scalePV);
 446
 447   m_headersize = static_cast<kuint16>(fs.tellp());
 448   fs.seekp (0);
 449   fs.writeInt16 (m_headersize);
 450
 451   return ! fs.fail();
 452 }
 453
 454
 455 bool
 456 Array2dFile::arrayDataWrite (frnetorderstream& fs)
 457 {
 458   if (! fs) {
 459     sys_error (ERR_WARNING, "Tried to arrayDataWrite with !fs");
 460     return false;
 461   }
 462
 463   if (! m_arrayData)
 464     return false;
 465
 466   fs.seekp (m_headersize);
 467   int columnSize = m_ny * m_pixelSize;
 468   for (unsigned int ix = 0; ix < m_nx; ix++) {\r
 469     unsigned char* ptrColumn = m_arrayData[ix];\r
 470     if (NativeBigEndian()) {\r
 471       for (unsigned int iy = 0; iy < m_ny; iy++) {\r
 472         ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);\r
 473         fs.write (reinterpret_cast<const char*>(ptrColumn), m_pixelSize);\r
 474         ptrColumn += m_pixelSize;\r
 475       }\r
 476     } else \r
 477       fs.write (reinterpret_cast<const char*>(ptrColumn), columnSize);\r
 478   }\r
 479   if (m_dataType == DATA_TYPE_COMPLEX) {\r
 480     for (unsigned int ix = 0; ix < m_nx; ix++) {\r
 481       unsigned char* ptrColumn = m_imaginaryArrayData[ix];\r
 482       if (NativeBigEndian()) {\r
 483         for (unsigned int iy = 0; iy < m_ny; iy++) {\r
 484           ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);\r
 485           fs.write (reinterpret_cast<const char*>(ptrColumn), m_pixelSize);\r
 486           ptrColumn += m_pixelSize;\r
 487         }\r
 488       } else \r
 489         fs.write (reinterpret_cast<const char*>(ptrColumn), columnSize);\r
 490     }\r
 491   }\r
 492
 493   return true;
 494 }
 495
 496
 497 bool
 498 Array2dFile::arrayDataRead (frnetorderstream& fs)
 499 {
 500   if (! fs) {
 501     sys_error (ERR_WARNING, "Tried to arrayDataRead with ! fs");
 502     return false;
 503   }
 504
 505   if (! m_arrayData)
 506     return false;
 507
 508   fs.seekg (m_headersize);
 509   int columnSize = m_ny * m_pixelSize;
 510   for (unsigned int ix = 0; ix < m_nx; ix++) {\r
 511     unsigned char* ptrColumn = m_arrayData[ix];\r
 512     if (NativeBigEndian()) {\r
 513       for (unsigned int iy = 0; iy < m_ny; iy++) {\r
 514         fs.read (reinterpret_cast<char*>(ptrColumn), m_pixelSize);\r
 515         ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);\r
 516         ptrColumn += m_pixelSize;\r
 517       } \r
 518     } else\r
 519       fs.read (reinterpret_cast<char*>(ptrColumn), columnSize);\r
 520   }\r
 521   if (m_dataType == DATA_TYPE_COMPLEX) {\r
 522     for (unsigned int ix = 0; ix < m_nx; ix++) {\r
 523       unsigned char* ptrColumn = m_imaginaryArrayData[ix];\r
 524       if (NativeBigEndian()) {\r
 525         for (unsigned int iy = 0; iy < m_ny; iy++) {\r
 526           fs.read (reinterpret_cast<char*>(ptrColumn), m_pixelSize);\r
 527           ConvertReverseNetworkOrder (ptrColumn, m_pixelSize);\r
 528           ptrColumn += m_pixelSize;\r
 529         } \r
 530       } else\r
 531         fs.read (reinterpret_cast<char*>(ptrColumn), columnSize);\r
 532     }\r
 533   }\r
 534
 535   return true;
 536 }
 537
 538 bool
 539 Array2dFile::labelsRead (frnetorderstream& fs)
 540 {
 541   off_t pos = m_headersize + m_arraySize;
 542   fs.seekg (pos);
 543   if (fs.fail())
 544     return false;
 545
 546   for (int i = 0; i < m_numFileLabels; i++) {
 547     kuint16 labelType, year, month, day, hour, minute, second;
 548     kfloat64 calcTime;
 549
 550     fs.readInt16 (labelType);
 551     fs.readInt16 (year);
 552     fs.readInt16 (month);
 553     fs.readInt16 (day);
 554     fs.readInt16 (hour);
 555     fs.readInt16 (minute);
 556     fs.readInt16 (second);
 557     fs.readFloat64 (calcTime);
 558
 559     kuint16 strLength;
 560     fs.readInt16 (strLength);
 561     char* pszLabelStr = new char [strLength+1];
 562     fs.read (pszLabelStr, strLength);
 563     pszLabelStr[strLength] = 0;
 564
 565     Array2dFileLabel* pLabel = new Array2dFileLabel (labelType, pszLabelStr, calcTime);
 566     delete pszLabelStr;\r
 567     \r
 568     pLabel->setDateTime (year, month, day, hour, minute, second);
 569     m_labels.push_back (pLabel);\r
 570   }
 571
 572   return true;
 573 }
 574
 575 bool
 576 Array2dFile::labelsWrite (frnetorderstream& fs)
 577 {
 578   off_t pos = m_headersize + m_arraySize;
 579   fs.seekp (pos);
 580
 581   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
 582     const Array2dFileLabel& label = **l;
 583     kuint16 labelType = label.getLabelType();
 584     kfloat64 calcTime = label.getCalcTime();
 585     const char* const labelString = label.getLabelString().c_str();
 586     int year, month, day, hour, minute, second;
 587     kuint16 yearBuf, monthBuf, dayBuf, hourBuf, minuteBuf, secondBuf;
 588
 589     label.getDateTime (year, month, day, hour, minute, second);
 590     yearBuf = year; monthBuf = month; dayBuf = day;
 591     hourBuf = hour; minuteBuf = minute; secondBuf = second;
 592
 593     fs.writeInt16 (labelType);
 594     fs.writeInt16 (yearBuf);
 595     fs.writeInt16 (monthBuf);
 596     fs.writeInt16 (dayBuf);
 597     fs.writeInt16 (hourBuf);
 598     fs.writeInt16 (minuteBuf);
 599     fs.writeInt16 (secondBuf);
 600     fs.writeFloat64 (calcTime);
 601     kuint16 strlength = strlen (labelString);
 602     fs.writeInt16 (strlength);
 603     fs.write (labelString, strlength);
 604   }
 605
 606   return true;
 607 }
 608
 609 void
 610 Array2dFile::labelAdd (const char* const lstr, double calc_time)
 611 {
 612   labelAdd (Array2dFileLabel::L_HISTORY, lstr, calc_time);
 613 }
 614
 615
 616 void
 617 Array2dFile::labelAdd (int type, const char* const lstr, double calc_time)
 618 {
 619   Array2dFileLabel label (type, lstr, calc_time);
 620
 621   labelAdd (label);
 622 }
 623
 624
 625 void
 626 Array2dFile::labelAdd (const Array2dFileLabel& label)
 627 {
 628   Array2dFileLabel* pLabel = new Array2dFileLabel(label);
 629
 630   m_labels.push_back (pLabel);
 631 }
 632
 633 void
 634 Array2dFile::labelsCopy (Array2dFile& copyFile, const char* const pszId)
 635 {
 636   std::string id;
 637   if (pszId)
 638     id = pszId;
 639   for (unsigned int i = 0; i < copyFile.getNumLabels(); i++) {
 640     Array2dFileLabel l (copyFile.labelGet (i));
 641     std::string lstr = l.getLabelString();
 642     lstr = id + lstr;
 643     l.setLabelString (lstr);
 644     labelAdd (l);
 645   }
 646 }
 647
 648 void
 649 Array2dFile::arrayDataClear (void)
 650 {
 651   if (m_arrayData) {\r
 652     int columnSize = m_ny * m_pixelSize;\r
 653     for (unsigned int ix = 0; ix < m_nx; ix++)\r
 654       memset (m_arrayData[ix], 0, columnSize);\r
 655   }\r
 656   if (m_imaginaryArrayData) {\r
 657     int columnSize = m_ny * m_pixelSize;\r
 658     for (unsigned int ix = 0; ix < m_nx; ix++)\r
 659       memset (m_arrayData[ix], 0, columnSize);\r
 660   }\r
 661 }
 662
 663 void
 664 Array2dFile::printLabels (std::ostream& os) const
 665 {
 666   for (constLabelIterator l = m_labels.begin(); l != m_labels.end(); l++) {
 667     const Array2dFileLabel& label = **l;
 668
 669     label.print (os);
 670     os << std::endl;
 671   }
 672 }
 673
 674
 675 const Array2dFileLabel&
 676 Array2dFile::labelGet (int i) const
 677 {
 678   return *m_labels[i];
 679 }