Changeset 3028 for trunk/psLib/test/fileUtils/tst_psFits.c

Timestamp:

Jan 17, 2005, 5:15:04 PM (22 years ago)

Author:

desonia

Message:

Added tests for psFitsReadImage & psFitsWriteImage. Also re-enabled
some 'not a requirement' code to support a superset of the required
datatype for various functions.

File:

• trunk/psLib/test/fileUtils/tst_psFits.c (modified) (7 diffs)

trunk/psLib/test/fileUtils/tst_psFits.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-01-17 20:58:22 $
+*  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-01-18 03:15:03 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -17 +17 @@
 #include <unistd.h>
 #include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+
+#define GENIMAGE(img,c,r,TYP, valueFcn) \
+img = psImageAlloc(c,r,PS_TYPE_##TYP); \
+for (psU32 row=0;row<r;row++) { \
+    ps##TYP* imgRow = img->data.TYP[row]; \
+    for (psU32 col=0;col<c;col++) { \
+        imgRow[col] = (ps##TYP)(valueFcn); \
+    } \
+}
 
 static bool makeMulti(void);  // implicitly tests psFitsSetExtName
@@ -23 +35 @@
 const char* tableFilename = "table.fits";
 const int tableNumRows = 10;
+
+
+// N.B., the tests to Image read/write was liberally taken from the now
+// deprecated psImageReadSection/psImageWriteSection function tests.
+static psS32 testImageRead(void);
+static psS32 testImageWrite(void);
 
 static psS32 tst_psFitsAlloc( void );
@@ -41 +59 @@
                               {tst_psFitsReadHeaderSet,805, "psFitsReadHeaderSet", 0, false},
                               {tst_psFitsReadTable,809, "psFitsReadTable", 0, false},
+                              {testImageRead,567, "psFitsReadImage", 0, false},
+                              {testImageWrite,569, "psFitsWriteImage", 0, false},
                               {NULL}
                           };
@@ -95 +115 @@
             // set the pixels in the image
             psBinaryOp(image,image,"=",psScalarAlloc(lcv,PS_TYPE_F32));
-            if (! psFitsWriteImage(fitsFile,header,image,1) ) {
+            if (! psFitsWriteImage(fitsFile,header,image,1, extname) ) {
                 psError(PS_ERR_UNKNOWN, false,
                         "Could not write image.");
                 return false;
             }
-            if (! psFitsSetExtName(fitsFile,extname) ) {
-                psError(PS_ERR_UNKNOWN, false,
-                        "Could not write extension name.");
-                return false;
-            }
 
             psFree(header);
@@ -130 +145 @@
         psImage* image = psImageAlloc(16,16,PS_TYPE_F32);
 
-        if (! psFitsWriteImage(fitsFile,NULL,image,1) ) {
+        if (! psFitsWriteImage(fitsFile,NULL,image,1,"primary") ) {
             psError(PS_ERR_UNKNOWN, false,
                     "Could not write PHU image.");
@@ -873 +888 @@
     return 0;
 }
+
+psS32 testImageRead(void)
+{
+    psS32 N = 256;
+    psS32 M = 128;
+
+    /*
+        This function shall open the specified FITS file, read the specified data
+        and place the data into a psImage structure. This function shall generate
+        an error message and return NULL if any of the input parameters are out of
+        range, image file doesn't exist or image is zero or one dimensional.
+
+        Verify the returned psImage structure contains expected values, if the input
+        parameter filename specifies an available FITS file with known 2dimensional
+        data, input parameters col, row, ncol, nrow, z specify data range with the
+        FITS file. Cases should include 1x1, Nx1, 1xN, NxN and MxN sub images and
+        total FITS file image. (done in macro)
+
+        Verify the returned psImage structure is equal to the input parameter
+        'output', if specified. (done in macro)
+
+        */
+
+    /* generate FITS file to read */
+
+    #define testReadTypeSize(m, n, readM0, readN0, readM, readN, TYP, filename) \
+    { \
+        psImage* img = NULL; \
+        psImage* img2 = NULL; \
+        psImage* img3 = NULL; \
+        psImage* img4 = NULL; \
+        /*        psImagimge* img_ref = NULL; */ \
+        \
+        GENIMAGE(img,m,n,TYP,row+2*col); \
+        img2 = psImageCopy(img2,img,PS_TYPE_##TYP); \
+        GENIMAGE(img3,m,n,TYP,row+2*col); \
+        psImageClip(img3,32.0,32.0,120.0,120.0); \
+        img4 = psImageCopy(img4,img3,PS_TYPE_##TYP); \
+        remove(filename); \
+        psFits* fits = psFitsAlloc(filename); \
+        psRegion region = {0,0,0,0}; \
+        if (! psFitsWriteImage(fits, NULL, img, 2, "primary")) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to write test image %s",filename); \
+            return 1; \
+        } \
+        if (! psFitsUpdateImage(fits,img3, region, 1)) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to write test image %s",filename); \
+            return 2; \
+        } \
+        if (! psFitsWriteImage(fits,NULL, img3, 2, "extension")) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to write test image %s",filename); \
+            return 3; \
+        } \
+        if (! psFitsUpdateImage(fits,img,region, 1)) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to write test image %s",filename); \
+            return 4; \
+        } \
+        psFree(img); \
+        psFree(fits); \
+        img = NULL; \
+        psFree(img3); \
+        img3 = NULL; \
+        fits = psFitsAlloc(filename); \
+        psRegion reg = {readM0, readM, readN0, readN}; \
+        img = psFitsReadImage(img, fits, reg, 0); \
+        img3 = psFitsReadImage(img3, fits, reg, 1); \
+        if (img3 == NULL) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to read test image %s",filename); \
+            return 6; \
+        } \
+        for (psU32 row = readN0; row < readN; row++) { \
+            ps##TYP* imgRow = img->data.TYP[row-readN0]; \
+            ps##TYP* img2Row = img2->data.TYP[row]; \
+            ps##TYP* img3Row = img3->data.TYP[row-readN0]; \
+            ps##TYP* img4Row = img4->data.TYP[row]; \
+            for (psU32 col = readM0; col < readM; col++) { \
+                if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \
+                    psError(PS_ERR_UNKNOWN, true,"Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \
+                            col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \
+                    return 7; \
+                } \
+                if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \
+                    psError(PS_ERR_UNKNOWN, true,"Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \
+                            col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \
+                    return 8; \
+                } \
+            } \
+        } \
+        psFree(img); \
+        img = NULL; \
+        psFree(img3); \
+        img3 = NULL; \
+        psFitsMoveExtNum(fits,1, false); \
+        img3 = psFitsReadImage(img3, fits, reg, 0); \
+        img = psFitsReadImage(img, fits, reg, 1); \
+        if (img == NULL) { \
+            psError(PS_ERR_UNKNOWN, true,"Failed to read test image %s",filename); \
+            return 9; \
+        } \
+        for (psU32 row = readN0; row < readN; row++) { \
+            ps##TYP* imgRow = img->data.TYP[row-readN0]; \
+            ps##TYP* img2Row = img2->data.TYP[row]; \
+            ps##TYP* img3Row = img3->data.TYP[row-readN0]; \
+            ps##TYP* img4Row = img4->data.TYP[row]; \
+            for (psU32 col = readM0; col < readM; col++) { \
+                if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \
+                    psError(PS_ERR_UNKNOWN, true,"Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \
+                            col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \
+                    return 10; \
+                } \
+                if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \
+                    psError(PS_ERR_UNKNOWN, true,"Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \
+                            col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \
+                    return 11; \
+                } \
+            } \
+        } \
+        psFree(img); \
+        psFree(img2); \
+        psFree(img3); \
+        psFree(img4); \
+        psFree(fits); \
+    }
+
+    #define testReadType(TYP,filename) \
+    testReadTypeSize(1,1,0,0,0,0,TYP,"tmpImages/1x1_" filename); \
+    testReadTypeSize(M,1,M/4,0,M*3/4,0,TYP,"tmpImages/Mx1_" filename); \
+    testReadTypeSize(1,N,0,N/4,0,N*3/4,TYP,"tmpImages/1xN_" filename); \
+    testReadTypeSize(M,N,M/4,N/4,M*3/4,N*3/4,TYP,"tmpImages/MxN_" filename);
+
+    mkdir("tmpImages",0777);
+
+    testReadTypeSize(1,1,0,0,0,0,U8,"tmpImages/1x1_" "U8.fits");
+    testReadTypeSize(M,1,M/4,0,M*3/4,0,U8,"tmpImages/Mx1_" "U8.fits");
+    testReadTypeSize(1,N,0,N/4,0,N*3/4,U8,"tmpImages/1xN_" "U8.fits");
+    testReadTypeSize(M,N,M/4,N/4,M*3/4,N*3/4,U8,"tmpImages/MxN_" "U8.fits");
+
+
+    testReadType(U8,"U8.fits");
+    testReadType(S8,"S8.fits");   // Not a requirement
+    testReadType(S16,"S16.fits");
+    testReadType(U16,"U16.fits"); // Not a requirement
+    testReadType(S32,"S32.fits");
+    testReadType(U32,"U32.fits"); // Not a requirement
+    testReadType(F32,"F32.fits");
+    testReadType(F64,"F64.fits");
+
+    return 0;
+}
+
+psS32 testImageWrite(void)
+{
+    psImage* img = NULL;
+    psImage* img2 = NULL;
+    psS32 m = 64;
+    psS32 n = 96;
+
+    /*
+    This function shall write the specified section within a psImage structure
+    to a FITS file. If the specifiedfile exists, then data should overwrite the
+    section to write. If the specified file doesn't exist, it shall be created.
+    If an extenstion is specified, then a basic primary header data unit shall
+    be created.
+    */
+
+    /*
+    Verify a FITS file named filename is generated and contains expected
+    values, if the input parameter input contains known data values, input
+    parameters col, row, ncol, nrow specify a valid data region within psImage
+    structure.
+
+    Verify a FITS file named filename is generated and contains a primary
+    header data unit with extension with expected values, if the input
+    parameter input contains known data values, input parameters col, row,
+    ncol, nrow specify a valid data region within psImage structure and
+    extname and/or extnum specify an extenstion to write.
+
+    N.B. : these are done in testImageRead tests, see above.
+    */
+
+    /*
+    Verify a FITS file named filename is overwritten and contains
+    expected values, if the input parameter input contains known data values,
+    input parameters col, row, ncol, nrow specify a valid data region within
+    psImage structure.
+    */
+
+    GENIMAGE(img,m,n,F32,0);
+    GENIMAGE(img2,m,n,F32,row+2*col);
+    mkdir("tmpImages",0777);
+    remove
+        ("tmpImages/writeTest.fits");
+    psRegion region = {
+                          0,0,0,0
+                      };
+    psFits* fits = psFitsAlloc("tmpImages/writeTest.fits");
+
+    if (! psFitsWriteImage(fits, NULL, img,1,NULL)) {
+        psError(PS_ERR_UNKNOWN, true,"Couldn't write writeTest.fits.");
+        return 14;
+    }
+    if (! psFitsUpdateImage(fits, img2, region, 0)) {
+        psError(PS_ERR_UNKNOWN, true,"Couldn't update writeTest.fits.");
+        return 15;
+    }
+    psFree(img);
+    psFree(img2);
+
+    // Did it really overwrite the pixel values?  Let's read it in and see.
+    psFree(fits);
+    fits = psFitsAlloc("tmpImages/writeTest.fits");
+    img = psFitsReadImage(NULL, fits, region, 0);
+    if (img == NULL) {
+        psError(PS_ERR_UNKNOWN, true,"Could not read in writeTest.fits.");
+        return 16;
+    }
+    for (psU32 row=0;row<n;row++) {
+        psF32* imgRow = img->data.F32[row];
+        for (psU32 col=0;col<m;col++) {
+            if (fabsf(imgRow[col] - (row+2*col)) > FLT_EPSILON) {
+                psError(PS_ERR_UNKNOWN, true,"The image values were not overwritten at %d,%d (%.2f vs %.2f)",
+                        col,row,imgRow[col],(row+2*col));
+                return 17;
+            }
+        }
+    }
+
+    psFree(img);
+
+    /*
+    Verify false is returned and program execution is not stopped, if the input image
+    is null.
+    */
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message because input image is null.");
+    if ( psFitsWriteImage(fits,NULL,NULL, 1, NULL) ) {
+        psError(PS_ERR_UNKNOWN, true,"psImageWriteSection did not return false when input image is NULL.");
+        return 20;
+    }
+
+    psFree(fits);
+
+    return 0;
+}