Changeset 2204 for trunk/psLib/test/image/tst_psImageManip.c

Timestamp:

Oct 26, 2004, 2:57:34 PM (22 years ago)

Author:

desonia

Message:

converted native C types to ps Types, where practical.

File:

• trunk/psLib/test/image/tst_psImageManip.c (modified) (46 diffs)

trunk/psLib/test/image/tst_psImageManip.c

@@ -6 +6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-14 01:22:59 $
+ *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-27 00:57:33 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -25 +25 @@
 #include "psType.h"
 
-static int testImageClip(void);
-static int testImageClipNAN(void);
-static int testImageClipComplexRegion(void);
-static int testImageOverlay(void);
-static int testImageRebin(void);
-static int testImageRoll(void);
-static int testImageRotate(void);
-static int testImageShift(void);
-static int testImageShiftCase(int cols, int rows, float colShift,float rowShift);
-static int testImageResample(void);
+static psS32 testImageClip(void);
+static psS32 testImageClipNAN(void);
+static psS32 testImageClipComplexRegion(void);
+static psS32 testImageOverlay(void);
+static psS32 testImageRebin(void);
+static psS32 testImageRoll(void);
+static psS32 testImageRotate(void);
+static psS32 testImageShift(void);
+static psS32 testImageShiftCase(psS32 cols, psS32 rows, float colShift,float rowShift);
+static psS32 testImageResample(void);
 
 testDescription tests[] = {
@@ -49 +49 @@
                           };
 
-int main(int argc, char* argv[])
+psS32 main(psS32 argc, char* argv[])
 {
     psLogSetLevel(PS_LOG_INFO);
@@ -57 +57 @@
 
 
-int testImageClip(void)
+psS32 testImageClip(void)
 {
     psImage* img = NULL;
-    unsigned int c = 128;
-    unsigned int r = 256;
+    psU32 c = 128;
+    psU32 r = 256;
     psF64 min;
     psF64 max;
-    int numClipped = 0;
-    int retVal;
+    psS32 numClipped = 0;
+    psS32 retVal;
 
     psLogMsg(__func__,PS_LOG_INFO,
@@ -95 +95 @@
     #define testImageClipByType(datatype) \
     img = psImageAlloc(c,r,PS_TYPE_##datatype); \
-    for (unsigned int row=0;row<r;row++) { \
+    for (psU32 row=0;row<r;row++) { \
         ps##datatype* imgRow = img->data.datatype[row]; \
-        for (unsigned int col=0;col<c;col++) { \
+        for (psU32 col=0;col<c;col++) { \
             imgRow[col] = (ps##datatype)(row+col); \
         } \
@@ -107 +107 @@
     \
     numClipped = 0; \
-    for (unsigned int row=0;row<r;row++) { \
+    for (psU32 row=0;row<r;row++) { \
         ps##datatype* imgRow = img->data.datatype[row]; \
-        for (unsigned int col=0;col<c;col++) { \
+        for (psU32 col=0;col<c;col++) { \
             ps##datatype value = (ps##datatype)(row+col); \
             if (value < min) { \
@@ -134 +134 @@
     #define testImageClipByComplexType(datatype) \
     img = psImageAlloc(c,r,PS_TYPE_##datatype); \
-    for (unsigned int row=0;row<r;row++) { \
+    for (psU32 row=0;row<r;row++) { \
         ps##datatype* imgRow = img->data.datatype[row]; \
-        for (unsigned int col=0;col<c;col++) { \
+        for (psU32 col=0;col<c;col++) { \
             imgRow[col] = (ps##datatype)(row+I*col); \
         } \
@@ -146 +146 @@
     \
     numClipped = 0; \
-    for (unsigned int row=0;row<r;row++) { \
+    for (psU32 row=0;row<r;row++) { \
         ps##datatype* imgRow = img->data.datatype[row]; \
-        for (unsigned int col=0;col<c;col++) { \
+        for (psU32 col=0;col<c;col++) { \
             ps##datatype value = row+I*col; \
             if (cabs(value) < min) { \
@@ -225 +225 @@
 }
 
-int testImageClipNAN(void)
+psS32 testImageClipNAN(void)
 {
     psImage* img = NULL;
-    unsigned int c = 128;
-    unsigned int r = 256;
-    int numClipped = 0;
-    int retVal;
+    psU32 c = 128;
+    psU32 r = 256;
+    psS32 numClipped = 0;
+    psS32 retVal;
 
     psLogMsg(__func__,PS_LOG_INFO,
@@ -317 +317 @@
 }
 
-int testImageClipComplexRegion(void)
+psS32 testImageClipComplexRegion(void)
 {
     psImage* img = NULL;
-    unsigned int c = 1024;
-    unsigned int r = 2048;
-    int numClipped = 0;
-    int retVal;
+    psU32 c = 1024;
+    psU32 r = 2048;
+    psS32 numClipped = 0;
+    psS32 retVal;
 
     psLogMsg(__func__,PS_LOG_INFO,
@@ -581 +581 @@
 }
 
-int testImageOverlay(void)
+psS32 testImageOverlay(void)
 {
 
@@ -588 +588 @@
     psImage* img3 = NULL;
     psImage* img4 = NULL;
-    unsigned int c = 128;
-    unsigned int r = 256;
-    int retVal;
+    psU32 c = 128;
+    psU32 r = 256;
+    psS32 retVal;
 
     /*
@@ -833 +833 @@
 }
 
-static int testImageRebin(void)
+static psS32 testImageRebin(void)
 {
 
@@ -869 +869 @@
     memset(meanTruthWMask->data.F32[0],0,sizeof(psF32)*4*4); \
     memset(maxTruth->data.F32[0],0,sizeof(psF32)*6*6); \
-    for (int row = 0; row<16; row++) { \
+    for (psS32 row = 0; row<16; row++) { \
         ps##DATATYPE* inRow = in->data.DATATYPE[row]; \
         psF32* meanTruthRow = meanTruth->data.F32[row/4]; \
@@ -875 +875 @@
         psF32* maxTruthRow = maxTruth->data.F32[row/3]; \
         psU8* maskRow = mask->data.U8[row]; \
-        for (int col = 0; col<16; col++) { \
+        for (psS32 col = 0; col<16; col++) { \
             if(col != 15) { \
                 maskRow[col] = 0; \
@@ -891 +891 @@
         } \
     } \
-    for (int row = 0; row<4; row++) { \
+    for (psS32 row = 0; row<4; row++) { \
         psF32* meanTruthRow = meanTruth->data.F32[row]; \
         psF32* meanTruthWMaskRow = meanTruthWMask->data.F32[row]; \
-        for (int col = 0; col<4; col++) { \
+        for (psS32 col = 0; col<4; col++) { \
             meanTruthRow[col] /= 16; \
             if ( col == 3 ) { \
@@ -915 +915 @@
         return 2; \
     } \
-    for (int row = 0; row<4; row++) { \
+    for (psS32 row = 0; row<4; row++) { \
         ps##DATATYPE* outRow = out->data.DATATYPE[row]; \
         psF32* truthRow = meanTruth->data.F32[row]; \
-        for (int col = 0; col<4; col++) { \
+        for (psS32 col = 0; col<4; col++) { \
             if (fabsf((float)outRow[col]-(float)truthRow[col]) > FLT_EPSILON) { \
                 psError(__func__,"psImageRebin didn't produce the proper mean " \
@@ -929 +929 @@
     stats.options = PS_STAT_SAMPLE_MEAN; \
     out3 = psImageRebin(NULL,in,mask,1,4,&stats); \
-    for (int row = 0; row<4; row++) { \
+    for (psS32 row = 0; row<4; row++) { \
         ps##DATATYPE* outRow = out3->data.DATATYPE[row]; \
         psF32* truthRow = meanTruthWMask->data.F32[row]; \
-        for ( int col = 0; col<4; col++) { \
-            if(abs((int)outRow[col]-(int)truthRow[col]) > FLT_EPSILON) { \
+        for ( psS32 col = 0; col<4; col++) { \
+            if(abs((psS32)outRow[col]-(psS32)truthRow[col]) > FLT_EPSILON) { \
                 psError(__func__,"psImageRebin with mask didn't produce the proper mean " \
                         "result at (%d,%d) [%f vs %f].", \
@@ -957 +957 @@
         return 5; \
     } \
-    for (int row = 0; row<6; row++) { \
+    for (psS32 row = 0; row<6; row++) { \
         ps##DATATYPE* outRow = out->data.DATATYPE[row]; \
         psF32* truthRow = maxTruth->data.F32[row]; \
-        for (int col = 0; col<6; col++) { \
+        for (psS32 col = 0; col<6; col++) { \
             if (fabsf((float)outRow[col]-(float)truthRow[col]) > FLT_EPSILON) { \
                 psError(__func__,"psImageRebin didn't produce the proper " \
@@ -1082 +1082 @@
 }
 
-static int testImageRoll(void)
+static psS32 testImageRoll(void)
 {
 
@@ -1088 +1088 @@
     psImage* out;
     psImage* out2;
-    int rows = 64;
-    int cols = 64;
-    int rows1 = 8;
-    int cols1 = 8;
+    psS32 rows = 64;
+    psS32 cols = 64;
+    psS32 rows1 = 8;
+    psS32 cols1 = 8;
 
     /*
@@ -1108 +1108 @@
 
     in = psImageAlloc(cols,rows,PS_TYPE_F32);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             inRow[col] = (psF32)row+(psF32)col/1000.0f;
         }
@@ -1116 +1116 @@
 
     out = psImageRoll(NULL,in,0,0);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[row];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[col] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1130 +1130 @@
 
     out2 = psImageRoll(out,in,cols/4,0);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[row];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[(col+cols/4) % cols] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1151 +1151 @@
 
     out = psImageRoll(out,in,0,rows/4);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[(row+rows/4)%rows];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[col] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1165 +1165 @@
 
     out = psImageRoll(out,in,cols/4,rows/4);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[(row+rows/4)%rows];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[(col+cols/4) % cols] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1179 +1179 @@
 
     out = psImageRoll(out,in,-cols/4,0);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[row];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[(col+(cols-cols/4)) % cols] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1193 +1193 @@
 
     out = psImageRoll(out,in,0,-rows/4);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[(row+rows-rows/4)%rows];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[col] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1207 +1207 @@
 
     out = psImageRoll(out,in,-cols/4,-rows/4);
-    for (int row=0;row<rows;row++) {
+    for (psS32 row=0;row<rows;row++) {
         psF32* inRow = in->data.F32[(row+rows-rows/4)%rows];
         psF32* outRow = out->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             if (inRow[(col+cols-cols/4) % cols] != outRow[col]) {
                 psError(__func__,"psImageRoll didn't produce expected result "
@@ -1236 +1236 @@
     in = psImageAlloc(rows1,cols1,PS_TYPE_##DATATYPE); \
     \
-    for (int row=0;row<rows1;row++) { \
+    for (psS32 row=0;row<rows1;row++) { \
         ps##DATATYPE* inRow = in->data.DATATYPE[row]; \
-        for (int col=0;col<cols1;col++) { \
+        for (psS32 col=0;col<cols1;col++) { \
             inRow[col] = (ps##DATATYPE)row+(ps##DATATYPE)col; \
         } \
@@ -1244 +1244 @@
     \
     out = psImageRoll(NULL,in,rows1/4,cols1/4); \
-    for (int row=0;row<rows1;row++) { \
+    for (psS32 row=0;row<rows1;row++) { \
         ps##DATATYPE* inRow = in->data.DATATYPE[(row+rows1/4)%rows1]; \
         ps##DATATYPE* outRow = out->data.DATATYPE[row]; \
-        for (int col=0;col<cols1;col++) { \
+        for (psS32 col=0;col<cols1;col++) { \
             if (inRow[(col+cols1/4)%cols1] != outRow[col]) { \
                 psError(__func__,"psImageRoll didn't produce expected result " \
@@ -1270 +1270 @@
 }
 
-int testImageRotate(void)
+psS32 testImageRotate(void)
 {
     /*
@@ -1300 +1300 @@
     psImage* fBiTruth = NULL;
     psImage* sBiTruth = NULL;
-    int rows = 64;
-    int cols = 64;
+    psS32 rows = 64;
+    psS32 cols = 64;
     psImage* fImg = psImageAlloc(cols,rows,PS_TYPE_F32);
     psImage* sImg = psImageAlloc(cols,rows,PS_TYPE_S16);
     psImage* s32Img = psImageAlloc(cols,rows,PS_TYPE_S32);
 
-    for(int row=0;row<rows;row++) {
+    for(psS32 row=0;row<rows;row++) {
         psF32* fRow = fImg->data.F32[row];
         psS16* sRow = sImg->data.S16[row];
         psS32* s32Row = s32Img->data.S32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             fRow[col] = (psF32)(row)+(psF32)(col)/100.0f;
             sRow[col] = row-2*col;
@@ -1336 +1336 @@
         ("temp/sBiOut.fits");
     ;
-    int index = 0;
-    bool fail = false;
-    for (int rot=-180;rot<=180;rot+=45) {
+    psS32 index = 0;
+    psBool fail = false;
+    for (psS32 rot=-180;rot<=180;rot+=45) {
         psImage* oldOut = fOut;
         psImage* oldBiOut = fBiOut;
@@ -1388 +1388 @@
                 fail = true;
             } else {
-                for (int row=0;row<fTruth->numRows;row++) {
+                for (psS32 row=0;row<fTruth->numRows;row++) {
                     psF32* truthRow = fTruth->data.F32[row];
                     psF32* outRow = fOut->data.F32[row];
-                    for (int col=0;col<fTruth->numCols;col++) {
+                    for (psS32 col=0;col<fTruth->numCols;col++) {
                         if (fabsf(truthRow[col]-outRow[col]) > 1) {
                             psError(__func__,"Float Image mismatch (%f vs %f) at %d,%d.",
@@ -1409 +1409 @@
             if (sTruth->numRows != sOut->numRows ||
                     sTruth->numCols != sOut->numCols) {
-                psError(__func__,"Rotated short image size did not match truth "
+                psError(__func__,"Rotated psS16 image size did not match truth "
                         "image for %d deg rotation.",rot);
                 fail = true;
             } else {
-                for (int row=0;row<sTruth->numRows;row++) {
+                for (psS32 row=0;row<sTruth->numRows;row++) {
                     psS16* truthRow = sTruth->data.S16[row];
                     psS16* outRow = sOut->data.S16[row];
-                    for (int col=0;col<sTruth->numCols;col++) {
+                    for (psS32 col=0;col<sTruth->numCols;col++) {
                         if (fabsf(truthRow[col]-outRow[col]) > 1) {
                             psError(__func__,"Short Image mismatch (%d vs %d) "
@@ -1440 +1440 @@
                 fail = true;
             } else {
-                for (int row=0;row<fBiTruth->numRows;row++) {
+                for (psS32 row=0;row<fBiTruth->numRows;row++) {
                     psF32* truthRow = fBiTruth->data.F32[row];
                     psF32* outRow = fBiOut->data.F32[row];
-                    for (int col=0;col<fBiTruth->numCols;col++) {
+                    for (psS32 col=0;col<fBiTruth->numCols;col++) {
                         if (fabsf(truthRow[col]-outRow[col]) > 1) {
                             psError(__func__,"Float Image mismatch (%f vs %f) at %d,%d. BILINEAR",
@@ -1461 +1461 @@
             if (sBiTruth->numRows != sBiOut->numRows ||
                     sBiTruth->numCols != sBiOut->numCols) {
-                psError(__func__,"Rotated short image size did not match truth "
+                psError(__func__,"Rotated psS16 image size did not match truth "
                         "image for %d deg rotation. BILINEAR",rot);
                 fail = true;
             } else {
-                for (int row=0;row<sBiTruth->numRows;row++) {
+                for (psS32 row=0;row<sBiTruth->numRows;row++) {
                     psS16* truthRow = sBiTruth->data.S16[row];
                     psS16* outRow = sBiOut->data.S16[row];
-                    for (int col=0;col<sBiTruth->numCols;col++) {
+                    for (psS32 col=0;col<sBiTruth->numCols;col++) {
                         if (fabsf(truthRow[col]-outRow[col]) > 1) {
                             psError(__func__,"Short Image mismatch (%d vs %d) "
@@ -1537 +1537 @@
 }
 
-static int testImageShift(void)
+static psS32 testImageShift(void)
 {
     /* psImageShift:
@@ -1558 +1558 @@
     */
 
-    int retVal=0;
+    psS32 retVal=0;
 
     // integer shift
@@ -1627 +1627 @@
 }
 
-static int testImageShiftCase(int cols,
-                              int rows,
-                              float colShift,
-                              float rowShift)
+static psS32 testImageShiftCase(psS32 cols,
+                                psS32 rows,
+                                float colShift,
+                                float rowShift)
 {
     psImage* fOut = NULL;
@@ -1643 +1643 @@
     psImage* sBiOut = psImageAlloc(cols,rows,PS_TYPE_S16);
 
-    for(int row=0;row<rows;row++) {
+    for(psS32 row=0;row<rows;row++) {
         psF32* fRow = fImg->data.F32[row];
         psS16* sRow = sImg->data.S16[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             fRow[col] = (psF32)(row)+(psF32)(col)/100.0f;
             sRow[col] = row-2*col;
@@ -1657 +1657 @@
     sBiOut = psImageShift(sBiOut, sImg, colShift, rowShift, -1, PS_INTERPOLATE_BILINEAR);
 
-    for(int row=0;row<rows;row++) {
+    for(psS32 row=0;row<rows;row++) {
         psF32* fRow = fOut->data.F32[row];
         psS16* sRow = sOut->data.S16[row];
@@ -1663 +1663 @@
         psS16* sBiRow = sBiOut->data.S16[row];
 
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             psF32 fValue = psImagePixelInterpolate(fImg,col+colShift,
                                                    row+rowShift,NULL,0,NAN,PS_INTERPOLATE_FLAT);
@@ -1707 +1707 @@
 }
 
-static int testImageResample(void)
+static psS32 testImageResample(void)
 {
 
-    int rows = 60;
-    int cols = 80;
+    psS32 rows = 60;
+    psS32 cols = 80;
     psImage* result = NULL;
-    int scale = 4;
+    psS32 scale = 4;
     psErr* err;
 
     psImage* image = psImageAlloc(cols,rows,PS_TYPE_F32);
-    for(int row=0;row<rows;row++) {
+    for(psS32 row=0;row<rows;row++) {
         psF32* imageRow = image->data.F32[row];
-        for (int col=0;col<cols;col++) {
+        for (psS32 col=0;col<cols;col++) {
             imageRow[col] = row+2*col;
         }
@@ -1753 +1753 @@
 
     psF32 truthValue;
-    for(int row=0;row<result->numRows;row++) {
-        for (int col=0;col<result->numCols;col++) {
+    for(psS32 row=0;row<result->numRows;row++) {
+        for (psS32 col=0;col<result->numCols;col++) {
             truthValue = psImagePixelInterpolate(image,
                                                  (float)col/(float)scale,(float)row/(float)scale,