X-Git-Url: http://git.kpe.io/?p=ctsim.git;a=blobdiff_plain;f=include%2Fimagefile.h;h=2c145e0ba6b9de2998222a47b0c6cea3fdd75bdc;hp=098d0c7272c585291cbe9998c148786f06c067ad;hb=92a7e95f339442d5d87f0febcae338306e1c6edd;hpb=d3cab6c841a99b82b602f9d3b4ac7eb6b973331e

diff --git a/include/imagefile.h b/include/imagefile.h
index 098d0c7..2c145e0 100644
--- a/include/imagefile.h
+++ b/include/imagefile.h
@@ -70,17 +70,17 @@ 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;
+
+public:
 
   Array2d<T> *array;
 
@@ -111,13 +111,22 @@ public:
 
   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);
       
-  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()); }
@@ -134,66 +143,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 = new Array2d<T> (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 = new Array2d<T> (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;
+  mIncX = mMinY = 0;
+  mMinX = mMaxX = mMinY = mMaxY = 0;
+  mOffsetPV = 0;
+  mScalePV = 1;
   array = NULL;
   io = NULL;
 
@@ -203,53 +194,46 @@ 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();
+  headerWrite ();
+  if (file_id >= 0 && array != NULL) {
+    arrayDataWrite ();
+    close (file_id);
+    file_id = -1;
+  }
 }
 
 template<class T>
@@ -279,13 +263,64 @@ Array2dFile<T>::fileRead (void)
   if (array != NULL)
     delete array;
 
-  array = new Array2d<T> (nx, ny);
+  array = new Array2d<T> (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)
+{
+      if (array != NULL) {
+	T** da = array.GetArray();
+	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)
+{
+    if (adf != NULL) {
+      mOffsetPV = offset;
+      mScalePV = scale;
+
+      T** ad = adf->getArray();
+      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)
@@ -297,26 +332,26 @@ Array2dFile<T>::headerRead (void)
 
   lseek (file_id, 0, SEEK_SET);
   kuint16 file_signature;
-  kuint16 file_pixel_size;
-  kuint16 file_pixel_type;
+  kuint16 file_mPixelSize;
+  kuint16 file_mPixelType;
 
   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 (&file_mPixelType, file_id);
+  read_nint16 (&file_mPixelSize, file_id);
+  read_nint32 (&mNX, file_id);
+  read_nint32 (&mNY, file_id);
   read_nint16 (&axis_increment_known, file_id);
-  read_nfloat64 (&xinc, file_id);
-  read_nfloat64 (&yinc, file_id);
+  read_nfloat64 (&mIncX, file_id);
+  read_nfloat64 (&mIncY, 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);
+  read_nfloat64 (&mMinX, file_id);
+  read_nfloat64 (&mMaxX, file_id);
+  read_nfloat64 (&mMinY, file_id);
+  read_nfloat64 (&mMaxY, file_id);
+  read_nfloat64 (&mOffsetPV, file_id);
+  read_nfloat64 (&mScalePV, file_id);
 
   int read_headersize = lseek (file_id, 0, SEEK_CUR);
   if (read_headersize != headersize) {
@@ -327,12 +362,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);
   }
 
@@ -352,20 +387,20 @@ Array2dFile<T>::headerWrite (void)
   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 (&mPixelType, file_id);
+  write_nint16 (&mPixelSize, file_id);
+  write_nint32 (&mNX, file_id);
+  write_nint32 (&mNY, file_id);
   write_nint16 (&axis_increment_known, file_id);
-  write_nfloat64 (&xinc, file_id);
-  write_nfloat64 (&yinc, file_id);
+  write_nfloat64 (&mIncX, file_id);
+  write_nfloat64 (&mIncY, 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);
+  write_nfloat64 (&mMinX, file_id);
+  write_nfloat64 (&mMaxX, file_id);
+  write_nfloat64 (&mMinY, file_id);
+  write_nfloat64 (&mMaxY, file_id);
+  write_nfloat64 (&mOffsetPV, file_id);
+  write_nfloat64 (&mScalePV, file_id);
 
   headersize = lseek (file_id, 0, SEEK_CUR);
   lseek (file_id, 0, SEEK_SET);
@@ -384,33 +419,16 @@ Array2dFile<T>::arrayDataWrite (void)
   }
 
   lseek (file_id, headersize, SEEK_SET);
-  for (unsigned int ix = 0; ix < nx; ix++)
-    {
-      write (file_id, array->array_data[ix], ny * pixel_size);
-    }
+  for (unsigned int ix = 0; ix < mNX; ix++)
+      for (unsigned int iy = 0; iy < mNY; iy++) {
+	  T value = array->array_data[ix][iy];
+	  ConvertNetworkOrder (&value, sizeof(T));
+	  write (file_id, &array->array_data[ix][iy], mPixelSize);
+      }
 
   return (true);
 }
 
-template<class T>
-void
-Array2dFile<T>::fileClose (void)
-{
-  headerWrite ();
-  if (file_id >= 0 && array != NULL) {
-    arrayDataWrite ();
-    close (file_id);
-    file_id = -1;
-  }
-}
-
-template<class T>
-Array2dFile<T>::~Array2dFile (void)
-{
-    fileClose ();
-}
-
-
 template<class T>
 bool
 Array2dFile<T>::arrayDataRead (void)
@@ -421,10 +439,13 @@ Array2dFile<T>::arrayDataRead (void)
   }
 
   lseek (file_id, headersize, SEEK_SET);
-  for (int ix = 0; ix < nx; ix++) 
-    {
-      read (file_id, array->array_data[ix], ny * pixel_size);
-    }
+  T pixelBuffer;
+  for (int ix = 0; ix < mNX; ix++) 
+      for (unsigned int iy = 0; iy < mNY; iy++) {
+	  read (file_id, &pixelBuffer, mPixelSize);
+	  ConvertNetworkOrder (&pixelBuffer, sizeof(T));
+	  array->array_data[ix][iy] = pixelBuffer;
+      }
 
   return (true);
 }
@@ -555,17 +576,17 @@ public:
 
   F32Image (const char* const fname, unsigned int nx, unsigned int ny) : adf (fname, nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT32);
   }
 
   F32Image (unsigned int nx, unsigned int ny) : adf (nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT32);
   }
 
   F32Image (const char* const fname) : adf (fname)
   {
-      adf.pixel_type = Array2dFile<kfloat32>::FLOAT32;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT32);
   }
 
 #ifdef MPI_CT
@@ -586,17 +607,17 @@ public:
 
   F64Image (const char* const fname, unsigned int nx, unsigned int ny) : adf (fname, nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT64);
   }
 
   F64Image (unsigned int nx, unsigned int ny) : adf (nx, ny)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT64);
   }
 
   F64Image (const char* const fname) : adf (fname)
   {
-      adf.pixel_type = Array2dFile<kfloat64>::FLOAT64;
+      adf.setPixelType (Array2dFile<kfloat64>::FLOAT64);
   }
 };