X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=include%2Fimagefile.h;h=607f7166cd1cef4bd2f323c273830c0b38bb23e7;hp=098d0c7272c585291cbe9998c148786f06c067ad;hb=44ba9ce559d2d52cbd7bbea6bcd76242840fd3eb;hpb=44988be2820a83554d63ba264383c9e87807abc8

diff --git a/include/imagefile.h b/include/imagefile.h
index 098d0c7..607f716 100644
--- a/include/imagefile.h
+++ b/include/imagefile.h
@@ -2,26 +2,35 @@
 #define IDF_H
 
 #include <string>
-#include "kstddef.h"
-#include <array2d.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fstream>
+#include <iostream>
+#include "ctsupport.h"
+#include "fnetorderstream.h"
+#include "array2d.h"
 
 using namespace std;
 
+
 class Array2dFileLabel
 {
 private:
     void init (void);
+    Array2dFileLabel (const Array2dFileLabel&);
+    Array2dFileLabel& operator= (const Array2dFileLabel&);
 
 public:
-    kfloat64 calc_time;
-    kuint16 label_type;
-    kuint16 year;
-    kuint16 month;
-    kuint16 day;
-    kuint16 hour;
-    kuint16 minute;
-    kuint16 second;
-    string label_str;
+    kfloat64 m_calcTime;
+    kuint16 m_labelType;
+    kuint16 m_year;
+    kuint16 m_month;
+    kuint16 m_day;
+    kuint16 m_hour;
+    kuint16 m_minute;
+    kuint16 m_second;
+    string m_strLabel;
+    mutable string m_strDate;
 
     static const int L_EMPTY = 0;
     static const int L_HISTORY = 1;
@@ -36,15 +45,21 @@ public:
     ~Array2dFileLabel();
 
     const string& getLabelString (void) const
-	{ return label_str; }
+	{ return m_strLabel; }
 
     kfloat64 getCalcTime (void) const
-	{ return calc_time; }
+	{ return m_calcTime; }
 
     kfloat64 getLabelType (void) const
-	{ return label_type; }
+	{ return m_labelType; }
+
+    string& setLabelString (const char* const str)
+	{ m_strLabel = str; return (m_strLabel); }
 
-    void getDateString (string& str) const;
+    string& setLabelString (const string& str)
+	{ m_strLabel = str; return (m_strLabel); }
+
+    const string& getDateString () const;
 };
 
 
@@ -58,7 +73,7 @@ private:
   kuint16 headersize;
   string  filename;
   int file_id;
-  iostream *io;
+  frnetorderstream *m_pFS;
   bool bHeaderWritten;
   bool bDataWritten;
 
@@ -70,19 +85,22 @@ private:
 
   bool labelSeek (unsigned int label_num);
 
-public:
-  kuint16 pixel_size;
-  kuint16 pixel_type;
-  kuint32 nx;
-  kuint32 ny;
-
+  kuint16 mPixelSize;
   kuint16 axis_increment_known;
-  kfloat64 xinc, yinc;
+  kfloat64 mIncX, mIncY;
   kuint16 axis_extent_known;
-  kfloat64 xmin, xmax, ymin, ymax;
-  kfloat64 pv_offset, pv_scale;
+  kfloat64 mMinX, mMaxX, mMinY, mMaxY;
+  kfloat64 mOffsetPV, mScalePV;
+  kuint16 mPixelType;
+  kuint32 mNX;
+  kuint32 mNY;
+
+  Array2dFile (const Array2dFile&);
+  Array2dFile& operator= (const Array2dFile&);
+
+public:
 
-  Array2d<T> *array;
+  Array2d<T> array;
 
   static const int INT8 = 1;
   static const int UINT8 = 2;
@@ -105,25 +123,38 @@ public:
 
   void labelAdd (const Array2dFileLabel& label);
 
-  void labelAdd (const char* const label_str, double calc_time=0.);
+  void labelAdd (const char* const m_strLabel, double calc_time=0.);
 
-  void labelAdd (int type, const char* const label_str, double calc_time=0.);
+  void labelAdd (int type, const char* const m_strLabel, double calc_time=0.);
+
+  void labelsCopy (Array2dFile& file, const char* const idStr = NULL);
 
   void fileClose (void);
 
-  void set_axis_increment (double xinc, double yinc);
+  void setPixelType (int type)
+      { mPixelType = type; }
+
+  kuint32 nx (void) const
+      { return mNX; }
+
+  kuint32 ny (void) const
+      { return mNY; }
+
+  void setAxisIncrement (double mIncX, double mIncY);
 
-  void set_axis_extent (double xmin, double xmax, double ymin, double ymax);
+  void setAxisExtent (double mMinX, double mMaxX, double mMinY, double mMaxY);
 
-  void get_pixel_extent (T& pvmin, T& pvmax);
+  void getPixelValueRange (T& pvmin, T& pvmax) const;
       
-  void set_pixel_offset_extent (double offset, double scale);
+  void doPixelOffsetScale (double offset, double scale);
 
   T** getArray (void) const
-      { return (array == NULL ? NULL : array->getArray()); }
+      { return (array.getArray()); }
 
   bool arrayDataWrite (void);
 
+  void arrayDataClear (void);
+
   bool fileRead (void);
 
   bool fileCreate (void);
@@ -134,68 +165,48 @@ public:
 
 
 template<class T>
-void
-Array2dFile<T>::set_axis_increment (double xinc, double yinc)
-{
-    axis_increment_known = true;
-    this.xinc = xinc;
-    this.yinc = yinc;
-}
-
-template<class T>
-void 
-Array2dFile<T>::set_axis_extent (double xmin, double xmax, double ymin, double ymax)
+Array2dFile<T>::Array2dFile (unsigned int x, unsigned int y)
 {
-    axis_extent_known = true;
-    this.xmin = xmin;
-    this.ymax = xmax;
-    this.xmin = xmin;
-    this.ymax = ymax;
+    init();
+    mNX = x;
+    mNY = y;
+    array.initSetSize(mNX, mNY);
 }
 
 template<class T>
-void 
-Array2dFile<T>::get_pixel_extent (T& pvmin, T& pvmax)
+Array2dFile<T>::Array2dFile (const char * const str, unsigned int x, unsigned int y)
+  : filename(str)
 {
-      if (array != NULL) {
-	T** da = array.GetArray();
-	pvmax = pvmin = da[0][0];
-	  for (int ix = 0; ix < nx; ix++)
-	      for (int iy = 0; iy < ny; iy++)
-		  if (pvmax < da[ix][iy])
-		      pvmax = da[ix][iy];
-		  else if (pvmin > da[ix][iy])
-		    pvmin = da[ix][iy];
-      }
+    init();
+    mNX = x;
+    mNY = y;
+    array.initSetSize(mNX, mNY);
 }
 
 template<class T>
-void
-Array2dFile<T>::set_pixel_offset_extent (double offset, double scale)
+Array2dFile<T>::Array2dFile (const char * const str)
+  : filename(str)
 {
-      pv_offset = offset;
-      pv_scale = scale;
+    init();
 }
 
 template<class T>
 void
 Array2dFile<T>::init (void)
 {
-  pixel_size = sizeof(T);
+  mPixelSize = sizeof(T);
   signature = ('I' * 256 + 'F');
-  file_id = -1;
-  nx = 0;
-  ny = 0;
+  mNX = 0;
+  mNY = 0;
   headersize = 0;
   num_labels = 0;
   axis_increment_known = false;
   axis_extent_known = false;
-  xinc = ymin = 0;
-  xmin = xmax = ymin = ymax = 0;
-  pv_offset = 0;
-  pv_scale = 1;
-  array = NULL;
-  io = NULL;
+  mIncX = mMinY = 0;
+  mMinX = mMaxX = mMinY = mMaxY = 0;
+  mOffsetPV = 0;
+  mScalePV = 1;
+  m_pFS = NULL;
 
 #if 0
   const type_info& t_id = typeid(T);
@@ -203,64 +214,56 @@ Array2dFile<T>::init (void)
   const type_info& comp_id = typeid(T);
 
   if (t_id == comp_id)
-      pixel_type = FLOAT64;
+      mPixelType = FLOAT64;
   else if (t_id == typeid(kfloat32))
-    pixel_type = FLOAT32;
+    mPixelType = FLOAT32;
   else if (t_id == typeid(kint32))
-    pixel_type = INT32;
+    mPixelType = INT32;
   else if (t_id == typeid(kuint32))
-    pixel_type = UINT32;
+    mPixelType = UINT32;
   else if (t_id == typeid(kint16))
-    pixel_type = INT16;
+    mPixelType = INT16;
   else if (t_id == typeid(kuint16))
-    pixel_type = UINT16;
+    mPixelType = UINT16;
   else if (t_id == typeid(kint8))
-    pixel_type = INT8;
+    mPixelType = INT8;
   else if (t_id == typeid(kuint8))
-    pixel_type = UINT8;
+    mPixelType = UINT8;
   else
 #endif
-      pixel_type = 0;
+      mPixelType = 0;
 
   bHeaderWritten = false;
   bDataWritten = false;
 }
 
 template<class T>
-Array2dFile<T>::Array2dFile (unsigned int x, unsigned int y)
+Array2dFile<T>::~Array2dFile (void)
 {
-    init();
-    nx = x;
-    ny = y;
-    array = new Array2d<T> (nx, ny);
+    fileClose ();
 }
 
-template<class T>
-Array2dFile<T>::Array2dFile (const char * const str, unsigned int x, unsigned int y)
-  : filename(str)
-{
-    init();
-    nx = x;
-    ny = y;
-    array = new Array2d<T> (nx, ny);
-}
 
 template<class T>
-Array2dFile<T>::Array2dFile (const char * const str)
-  : filename(str)
+void
+Array2dFile<T>::fileClose (void)
 {
-    init();
+  if (m_pFS) {
+      headerWrite ();
+      m_pFS->close ();
+      m_pFS = NULL;
+  }
 }
 
 template<class T>
 bool
 Array2dFile<T>::fileCreate (void)
 {
-  //  io = new iostream(filename, ios::out | ios::in | ios::trunc | io::binary);
-    if ((file_id = open (filename.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
-	sys_error (ERR_WARNING, "Error opening file %s for writing [fileCreate]", filename.c_str());
-	return (false);
-    }
+  m_pFS = new frnetorderstream (filename.c_str(), ios::out | ios::in | ios::trunc | ios::binary);
+  if (! m_pFS) {
+      sys_error (ERR_WARNING, "Error opening file %s for writing [fileCreate]", filename.c_str());
+      return (false);
+  }
   headerWrite();
   return (true);
 }
@@ -269,56 +272,106 @@ template<class T>
 bool
 Array2dFile<T>::fileRead (void)
 {
-  // io = new iostream(filename, ios::out | ios::in | io::binary);
-  if ((file_id = open (filename.c_str(), O_RDONLY | O_BINARY)) < 0) {
+  m_pFS = new frnetorderstream (filename.c_str(), ios::out | ios::in | ios::binary | ios::nocreate);
+  if (m_pFS->fail()) {
     sys_error (ERR_WARNING, "Unable to open file %s [fileRead]", filename.c_str());
     return (false);
   }
 
-  headerRead();
-  if (array != NULL)
-    delete array;
+  if (! headerRead())
+      return false;
 
-  array = new Array2d<T> (nx, ny);
+  array.initSetSize(mNX, mNY);
 
   arrayDataRead();
 
   return (true);
 }
 
+template<class T>
+void
+Array2dFile<T>::setAxisIncrement (double incX, double incY)
+{
+    axis_increment_known = true;
+    mIncX = incX;
+    mIncY = incY;
+}
+
+template<class T>
+void 
+Array2dFile<T>::setAxisExtent (double minX, double maxX, double minY, double maxY)
+{
+    axis_extent_known = true;
+    mMinX = minX;
+    mMaxY = maxX;
+    mMinX = minX;
+    mMaxY = maxY;
+}
+
+template<class T>
+void 
+Array2dFile<T>::getPixelValueRange (T& pvmin, T& pvmax) const
+{
+    T** da = array.getArray();
+    if (da) {
+	pvmax = pvmin = da[0][0];
+	for (int ix = 0; ix < mNX; ix++)
+	    for (int iy = 0; iy < mNY; iy++)
+		if (pvmax < da[ix][iy])
+		    pvmax = da[ix][iy];
+		else if (pvmin > da[ix][iy])
+		    pvmin = da[ix][iy];
+    }
+}
+
+template<class T>
+void
+Array2dFile<T>::doPixelOffsetScale (double offset, double scale)
+{
+    T** ad = array.getArray();
+    if (ad) {
+	mOffsetPV = offset;
+	mScalePV = scale;
+
+	for (unsigned int ix = 0; ix < mNX; ix++) 
+	    for (unsigned int iy = 0; iy < mNY; iy++)
+		ad[ix][iy] = (ad[ix][iy] - offset) * scale;
+    }
+}
+
 template<class T>
 bool
 Array2dFile<T>::headerRead (void)
 {
-  if (file_id < 0) {
+  if (! m_pFS) {
     sys_error (ERR_WARNING, "Tried to read header with file closed [headerRead]");
     return (false);
   }
 
-  lseek (file_id, 0, SEEK_SET);
+  m_pFS->seekg (0);
   kuint16 file_signature;
-  kuint16 file_pixel_size;
-  kuint16 file_pixel_type;
-
-  read_nint16 (&headersize, file_id);
-  read_nint16 (&file_signature, file_id);
-  read_nint16 (&num_labels, file_id);
-  read_nint16 (&file_pixel_type, file_id);
-  read_nint16 (&file_pixel_size, file_id);
-  read_nint32 (&nx, file_id);
-  read_nint32 (&ny, file_id);
-  read_nint16 (&axis_increment_known, file_id);
-  read_nfloat64 (&xinc, file_id);
-  read_nfloat64 (&yinc, file_id);
-  read_nint16 (&axis_extent_known, file_id);
-  read_nfloat64 (&xmin, file_id);
-  read_nfloat64 (&xmax, file_id);
-  read_nfloat64 (&ymin, file_id);
-  read_nfloat64 (&ymax, file_id);
-  read_nfloat64 (&pv_offset, file_id);
-  read_nfloat64 (&pv_scale, file_id);
-
-  int read_headersize = lseek (file_id, 0, SEEK_CUR);
+  kuint16 file_mPixelSize;
+  kuint16 file_mPixelType;
+
+  m_pFS->readInt16 (headersize);
+  m_pFS->readInt16 (file_signature);
+  m_pFS->readInt16 (num_labels);
+  m_pFS->readInt16 (file_mPixelType);
+  m_pFS->readInt16 (file_mPixelSize);
+  m_pFS->readInt32 (mNX);
+  m_pFS->readInt32 (mNY);
+  m_pFS->readInt16 (axis_increment_known);
+  m_pFS->readFloat64 (mIncX);
+  m_pFS->readFloat64 (mIncY);
+  m_pFS->readInt16 (axis_extent_known);
+  m_pFS->readFloat64 (mMinX);
+  m_pFS->readFloat64 (mMaxX);
+  m_pFS->readFloat64 (mMinY);
+  m_pFS->readFloat64 (mMaxY);
+  m_pFS->readFloat64 (mOffsetPV);
+  m_pFS->readFloat64 (mScalePV);
+
+  int read_headersize = m_pFS->tellg();
   if (read_headersize != headersize) {
     sys_error (ERR_WARNING, "Read headersize %d != file headersize %d", read_headersize, headersize);
     return (false);
@@ -327,12 +380,12 @@ Array2dFile<T>::headerRead (void)
     sys_error (ERR_WARNING, "File signature %d != true signature %d", file_signature, signature);
     return (false);
   }
-  if (file_pixel_type != pixel_type) {
-    sys_error (ERR_WARNING, "File pixel type %d != class pixel type %d", file_pixel_type, pixel_type);
+  if (file_mPixelType != mPixelType) {
+    sys_error (ERR_WARNING, "File pixel type %d != class pixel type %d", file_mPixelType, mPixelType);
     return (false);
   }
-  if (file_pixel_size != pixel_size) {
-    sys_error (ERR_WARNING, "File pixel size %d != class pixel size %d", file_pixel_size, pixel_size);
+  if (file_mPixelSize != mPixelSize) {
+    sys_error (ERR_WARNING, "File pixel size %d != class pixel size %d", file_mPixelSize, mPixelSize);
     return (false);
   }
 
@@ -343,33 +396,32 @@ template<class T>
 bool
 Array2dFile<T>::headerWrite (void)
 {
-  if (file_id < 0) {
+  if (! m_pFS) {
     sys_error (ERR_WARNING, "Tried to write header with file closed");
     return (false);
   }
 
-  lseek (file_id, 0, SEEK_SET);
-  write_nint16 (&headersize, file_id);
-  write_nint16 (&signature, file_id);
-  write_nint16 (&num_labels, file_id);
-  write_nint16 (&pixel_type, file_id);
-  write_nint16 (&pixel_size, file_id);
-  write_nint32 (&nx, file_id);
-  write_nint32 (&ny, file_id);
-  write_nint16 (&axis_increment_known, file_id);
-  write_nfloat64 (&xinc, file_id);
-  write_nfloat64 (&yinc, file_id);
-  write_nint16 (&axis_extent_known, file_id);
-  write_nfloat64 (&xmin, file_id);
-  write_nfloat64 (&xmax, file_id);
-  write_nfloat64 (&ymin, file_id);
-  write_nfloat64 (&ymax, file_id);
-  write_nfloat64 (&pv_offset, file_id);
-  write_nfloat64 (&pv_scale, file_id);
-
-  headersize = lseek (file_id, 0, SEEK_CUR);
-  lseek (file_id, 0, SEEK_SET);
-  write_nint16 (&headersize, file_id);
+  m_pFS->seekp (0);
+  m_pFS->writeInt16 (headersize);
+  m_pFS->writeInt16 (signature);
+  m_pFS->writeInt16 (num_labels);
+  m_pFS->writeInt16 (mPixelType);
+  m_pFS->writeInt16 (mPixelSize);
+  m_pFS->writeInt32 (mNX);
+  m_pFS->writeInt32 (mNY);
+  m_pFS->writeInt16 (axis_increment_known);
+  m_pFS->writeFloat64 (mIncX);
+  m_pFS->writeFloat64 (mIncY);
+  m_pFS->writeInt16 (axis_extent_known);
+  m_pFS->writeFloat64 (mMinX);
+  m_pFS->writeFloat64 (mMaxX);
+  m_pFS->writeFloat64 (mMinY);
+  m_pFS->writeFloat64 (mMaxY);
+  m_pFS->writeFloat64 (mOffsetPV);
+  m_pFS->writeFloat64 (mScalePV);
+
+  headersize = m_pFS->tellp();
+  m_pFS->writeInt16 (headersize);
   
   return (true);
 }
@@ -378,53 +430,56 @@ template<class T>
 bool
 Array2dFile<T>::arrayDataWrite (void)
 {
-  if (file_id < 0) {
-    sys_error (ERR_WARNING, "Tried to arrayDataWrite with file_id < 0");
+  if (! m_pFS) {
+    sys_error (ERR_WARNING, "Tried to arrayDataWrite with !m_pFS");
     return (false);
   }
 
-  lseek (file_id, headersize, SEEK_SET);
-  for (unsigned int ix = 0; ix < nx; ix++)
-    {
-      write (file_id, array->array_data[ix], ny * pixel_size);
-    }
-
-  return (true);
-}
-
-template<class T>
-void
-Array2dFile<T>::fileClose (void)
-{
-  headerWrite ();
-  if (file_id >= 0 && array != NULL) {
-    arrayDataWrite ();
-    close (file_id);
-    file_id = -1;
+  T** da = array.getArray();
+  if (! da) 
+      return (false);
+
+  m_pFS->seekp (headersize);
+  for (unsigned int ix = 0; ix < mNX; ix++) {
+      if (NativeBigEndian()) {
+	  for (unsigned int iy = 0; iy < mNY; iy++) {
+	      T value = da[ix][iy];
+	      ConvertReverseNetworkOrder (&value, sizeof(T));
+	      m_pFS->write (&value, mPixelSize);
+	  }
+      } else 
+	  m_pFS->write (da[ix], sizeof(T) * mNY);
   }
-}
 
-template<class T>
-Array2dFile<T>::~Array2dFile (void)
-{
-    fileClose ();
+  return (true);
 }
 
-
 template<class T>
 bool
 Array2dFile<T>::arrayDataRead (void)
 {
-  if (file_id < 0) {
-    sys_error (ERR_WARNING, "Tried to arrayDataRead with file_id < 0");
+  if (! m_pFS) {
+    sys_error (ERR_WARNING, "Tried to arrayDataRead with !m_pFS");
     return (false);
   }
 
-  lseek (file_id, headersize, SEEK_SET);
-  for (int ix = 0; ix < nx; ix++) 
-    {
-      read (file_id, array->array_data[ix], ny * pixel_size);
-    }
+  T** da = array.getArray();
+  if (! da) 
+      return (false);
+
+  m_pFS->seekg (headersize);
+  T pixelBuffer;
+  for (int ix = 0; ix < mNX; ix++) {
+      if (NativeBigEndian()) {
+	  for (unsigned int iy = 0; iy < mNY; iy++) {
+	      m_pFS->read (&pixelBuffer, mPixelSize);
+	      ConvertReverseNetworkOrder (&pixelBuffer, sizeof(T));
+	      da[ix][iy] = pixelBuffer;
+	  } 
+      } else
+	  m_pFS->read (da[ix], sizeof(T) * mNY);
+  }
+
 
   return (true);
 }
@@ -438,32 +493,27 @@ Array2dFile<T>::labelSeek (unsigned int label_num)
     return (false);
   }
 
-  if (array == NULL) {    // Could not have written data if array not allocated
+  if (array.getArray() == NULL) {    // Could not have written data if array not allocated
     sys_error (ERR_WARNING, "array == NULL [labelSeek]");
     return (false);
   }
 
-  off_t pos = headersize + array->sizeofArray();
-  if (lseek (file_id, pos, SEEK_SET) != pos) {
-    sys_error (ERR_WARNING, "Can't seek to end of data array");
-    return (false);
-  }
+  off_t pos = headersize + array.sizeofArray();
+  m_pFS->seekg (pos);
 
   for (int i = 0; i < label_num; i++)
       {
 	  pos += 22;  // Skip to string length
-	  if (lseek (file_id, pos, SEEK_SET) != pos) {
-	    sys_error (ERR_WARNING, "Can't seek to string length");
-	    return (false);
-	  }
+	  m_pFS->seekg (pos);
+	      
 	  kuint16 strlength;
-	  read_nint16 (&strlength, file_id);
+	  m_pFS->readInt16 (strlength);
 	  pos += 2 + strlength;  // Skip label string length + data
-	  if (lseek (file_id, pos, SEEK_SET) != pos) {
-	    sys_error (ERR_WARNING, "Can't seek past label string");
-	    return (false);
-	  }
+	  m_pFS->seekg (pos);
       }
+  
+  if (! m_pFS)
+      return false;
 
   return (true);
 }
@@ -482,20 +532,21 @@ Array2dFile<T>::labelRead (Array2dFileLabel& label, unsigned int label_num)
     return (false);
   }
 
-  read_nint16 (&label.label_type, file_id);
-  read_nint16 (&label.year, file_id);
-  read_nint16 (&label.month, file_id);
-  read_nint16 (&label.day, file_id);
-  read_nint16 (&label.hour, file_id);
-  read_nint16 (&label.minute, file_id);
-  read_nint16 (&label.second, file_id);
-  read_nfloat64 (&label.calc_time, file_id);
+  m_pFS->readInt16 (label.m_labelType);
+  m_pFS->readInt16 (label.m_year);
+  m_pFS->readInt16 (label.m_month);
+  m_pFS->readInt16 (label.m_day);
+  m_pFS->readInt16 (label.m_hour);
+  m_pFS->readInt16 (label.m_minute);
+  m_pFS->readInt16 (label.m_second);
+  m_pFS->readFloat64 (label.m_calcTime);
 
   kuint16 strlength;
-  read_nint16 (&strlength, file_id);
-  char *str = new char [strlength+1];
-  read (file_id, str, strlength);
-  label.label_str = str;
+  m_pFS->readInt16 (strlength);
+  char str [strlength+1];
+  m_pFS->read (str, strlength);
+  str[strlength] = 0;
+  label.m_strLabel = str;
 
   return (true);
 }
@@ -523,87 +574,125 @@ Array2dFile<T>::labelAdd (const Array2dFileLabel& label)
 {
   labelSeek (num_labels);
   
-  write_nint16 (&label.label_type, file_id);
-  write_nint16 (&label.year, file_id);
-  write_nint16 (&label.month, file_id);
-  write_nint16 (&label.day, file_id);
-  write_nint16 (&label.hour, file_id);
-  write_nint16 (&label.minute, file_id);
-  write_nint16 (&label.second, file_id);
-  write_nfloat64 (&label.calc_time, file_id);
-  kuint16 strlength = label.label_str.length();
-  write_nint16 (&strlength, file_id);
-  write (file_id, static_cast<const void*>(label.label_str.c_str()), strlength);
+  m_pFS->writeInt16 (label.m_labelType);
+  m_pFS->writeInt16 (label.m_year);
+  m_pFS->writeInt16 (label.m_month);
+  m_pFS->writeInt16 (label.m_day);
+  m_pFS->writeInt16 (label.m_hour);
+  m_pFS->writeInt16 (label.m_minute);
+  m_pFS->writeInt16 (label.m_second);
+  m_pFS->writeFloat64 (label.m_calcTime);
+  kuint16 strlength = label.m_strLabel.length();
+  m_pFS->writeInt16 (strlength);
+  m_pFS->write (label.m_strLabel.c_str(), strlength);
 
   num_labels++;
 
   headerWrite();
-  fsync(file_id);
 }
 
+template<class T>
+void
+Array2dFile<T>::labelsCopy (Array2dFile& copyFile, const char* const idStr)
+{
+    string id = idStr;
+    for (int i = 0; i < copyFile.getNumLabels(); i++) {
+      Array2dFileLabel l;
+      copyFile.labelRead (l, i);
+      string lstr = l.getLabelString();
+      lstr = idStr + lstr;
+      l.setLabelString (lstr);
+      labelAdd (l);
+    }
+}
 
-#endif
+template<class T>
+void 
+Array2dFile<T>::arrayDataClear (void)
+{
+    T** v = array.getArray();
+    if (v) {
+	for (unsigned int ix = 0; ix < mNX; ix++)
+	    for (unsigned int iy = 0; iy < mNY; iy++)
+		v[ix][iy] = 0;
+    }
+}
 
-#ifdef MPI_CT
-#include <mpi.h>
+
+#ifdef HAVE_MPI
+#include <mpi++.h>
 #endif
 
-class F32Image
+class F32Image : public Array2dFile<kfloat32>
 {
 public:
-  Array2dFile<kfloat32> adf;
-
-  F32Image (const char* const fname, unsigned int nx, unsigned int ny) : adf (fname, nx, ny)
+  F32Image (const char* const fname, unsigned int nx, unsigned int ny)
+      : Array2dFile<kfloat32>::Array2dFile (fname, nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      setPixelType (FLOAT32);
   }
 
-  F32Image (unsigned int nx, unsigned int ny) : adf (nx, ny)
+  F32Image (unsigned int nx, unsigned int ny)
+      : Array2dFile<kfloat32>::Array2dFile (nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      setPixelType (FLOAT32);
   }
 
-  F32Image (const char* const fname) : adf (fname)
+  F32Image (const char* const fname)
+      : Array2dFile<kfloat32>::Array2dFile (fname)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      setPixelType (FLOAT32);
   }
 
-#ifdef MPI_CT
-  MPI_Datatype getMPIDataType (void) const
-      { return MPI_FLOAT; }
+#ifdef HAVE_MPI
+  MPI::Datatype getMPIDataType (void) const
+      { return MPI::FLOAT; }
 #endif
 };
 
-class F64Image 
-{
-public:
-  Array2dFile<kfloat64> adf;
 
-#ifdef MPI_CT
-  MPI_Datatype getMPIDataType (void) const
-      { return MPI_DOUBLE; }
-#endif
+class F64Image : public Array2dFile<kfloat64>
+{
+ public:
 
-  F64Image (const char* const fname, unsigned int nx, unsigned int ny) : adf (fname, nx, ny)
+  F64Image (const char* const fname, unsigned int nx, unsigned int ny)
+      : Array2dFile<kfloat64>::Array2dFile (fname, nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      setPixelType (FLOAT64);
   }
 
-  F64Image (unsigned int nx, unsigned int ny) : adf (nx, ny)
+  F64Image (unsigned int nx, unsigned int ny)
+      : Array2dFile<kfloat64>::Array2dFile (nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      setPixelType (FLOAT64);
   }
 
-  F64Image (const char* const fname) : adf (fname)
+  F64Image (const char* const fname)
+      : Array2dFile<kfloat64>::Array2dFile (fname)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      setPixelType (FLOAT64);
   }
+
+#ifdef HAVE_MPI
+  MPI::Datatype getMPIDataType (void) const
+      { return MPI::DOUBLE; }
+#endif
 };
 
+#undef IMAGEFILE_64_BITS
+#ifdef IMAGEFILE_64_BITS
 typedef F64Image   ImageFile;
 typedef kfloat64   ImageFileValue;
 typedef kfloat64*  ImageFileColumn;
 typedef kfloat64** ImageFileArray;
+#else
+typedef F32Image   ImageFile;
+typedef kfloat32   ImageFileValue;
+typedef kfloat32*  ImageFileColumn;
+typedef kfloat32** ImageFileArray;
+#endif
+
+#endif