IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 2714


Ignore:
Timestamp:
Dec 14, 2004, 5:57:03 PM (22 years ago)
Author:
evanalst
Message:

Update for additional test cases.

Location:
trunk/psLib/test/image
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/image/tst_psImageFFT.c

    r2273 r2714  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2004-11-04 01:05:00 $
     8 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2004-12-15 03:57:03 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3434
    3535testDescription tests[] = {
    36                               {
    37                                   testImageFFT,632,"psImageFFT",0,false
    38                               },
    39                               {
    40                                   testImageRealImaginary,633,"psImageRealImaginary",0,false
    41                               },
    42                               {
    43                                   testImageComplex,634,"psImageComplex",0,false
    44                               },
    45                               {
    46                                   testImageConjugate,635,"psImageConjugate",0,false
    47                               },
    48                               {
    49                                   testImagePowerSpectrum,636,"psImagePowerSpectrum",0,false
    50                               },
    51                               {
    52                                   NULL
    53                               }
     36                              {testImageFFT,632,"psImageFFT",0,false},
     37                              {testImageRealImaginary,633,"psImageRealImaginary",0,false},
     38                              {testImageComplex,634,"psImageComplex",0,false},
     39                              {testImageConjugate,635,"psImageConjugate",0,false},
     40                              {testImagePowerSpectrum,636,"psImagePowerSpectrum",0,false},
     41                              {NULL}
    5442                          };
    5543
    … …  
    214202    psImage* img2 = NULL;
    215203    psImage* img3 = NULL;
     204    psImage* c64Img = NULL;
     205    psImage* c64Img2 = NULL;
     206    psImage* c64Img3 = NULL;
     207    psImage* ncImg = NULL;
     208    psImage* ncImg2 = NULL;
     209    psImage* ncImg3 = NULL;
     210
    216211    psU32 m = 128;
    217212    psU32 n = 64;
    … …  
    271266    psFree(img3);
    272267
     268    /*
     269    1. create a C64 complex vector with distinctly different real and imaginary parts.
     270    2. call psImageReal and psImageImaginary
     271    3. compare results to the real/imaginary components of input
     272    */
     273
     274    // 1. create a C64 complex vector with distinctly different real and imaginary parts.
     275    GENIMAGE(c64Img,m,n,C64, row + I * col);
     276
     277    // 2. call psImageReal and psImageImaginary
     278    c64Img2 = psImageReal(c64Img2,c64Img);
     279    if (c64Img2 == NULL) {
     280        psError(PS_ERR_UNKNOWN, true,"psImageReal returned a NULL?");
     281        return 1;
     282    }
     283    if (c64Img2->type.type != PS_TYPE_F64) {
     284        psError(PS_ERR_UNKNOWN, true,"psImageReal returned a wrong type (%d)?",
     285                img2->type.type);
     286        return 2;
     287    }
     288
     289    c64Img3 = psImageImaginary(c64Img3,c64Img);
     290    if (c64Img3 == NULL) {
     291        psError(PS_ERR_UNKNOWN, true,"psImageImaginary returned a NULL?");
     292        return 3;
     293    }
     294    if (c64Img3->type.type != PS_TYPE_F64) {
     295        psError(PS_ERR_UNKNOWN, true,"psImageImaginary returned a wrong type (%d)?",
     296                c64Img3->type.type);
     297        return 4;
     298    }
     299
     300    // 3. compare results to the real/imaginary components of input
     301    for (psU32 row=0;row<n;row++) {
     302        psF64* img2Row = c64Img2->data.F64[row];
     303        psF64* img3Row = c64Img3->data.F64[row];
     304        for (psU32 col=0;col<m;col++) {
     305            if (fabsf(img2Row[col] - row) > FLT_EPSILON) {
     306                psError(PS_ERR_UNKNOWN, true,"psImageReal didn't return the real portion at n=%d",
     307                        n);
     308                return 5;
     309            }
     310            if (fabsf(img3Row[col] - col) > FLT_EPSILON) {
     311                psError(PS_ERR_UNKNOWN, true,"psImageImaginary didn't return the imag portion at n=%d",
     312                        n);
     313                return 6;
     314            }
     315        }
     316    }
     317
     318    GENIMAGE(ncImg,m,n,F32,row+col);
     319    ncImg2 = psImageReal(ncImg2,ncImg);
     320    ncImg3 = psImageImaginary(ncImg3,ncImg);
     321    if(ncImg2 == NULL) {
     322        psError(PS_ERR_UNKNOWN,true,"psImageReal returned NULL");
     323        return 40;
     324    }
     325    if(ncImg2->type.type != PS_TYPE_F32) {
     326        psError(PS_ERR_UNKNOWN,true,"psImageReal returned a wrong type");
     327        return 41;
     328    }
     329    if(ncImg3 == NULL) {
     330        psError(PS_ERR_UNKNOWN,true,"psImageImaginary returned NULL");
     331        return 42;
     332    }
     333    if(ncImg3->type.type != PS_TYPE_F32) {
     334        psError(PS_ERR_UNKNOWN,true,"psImageImaginary returned NULL");
     335        return 43;
     336    }
     337    for(psU32 row=0; row<n; row++) {
     338        psF32* ncImg2Row = ncImg2->data.F32[row];
     339        psF32* ncImg3Row = ncImg3->data.F32[row];
     340        for(psU32 col=0; col<m; col++) {
     341            if(fabsf(ncImg2Row[col] - (row+col)) > FLT_EPSILON) {
     342                psError(PS_ERR_UNKNOWN,true,"psImageReal didn't return the real portion");
     343                return 45;
     344            }
     345            if(fabsf(ncImg3Row[col] - 0) > FLT_EPSILON) {
     346                psError(PS_ERR_UNKNOWN,true,"psImageImaginary didn't return the imaginary portion");
     347                return 46;
     348            }
     349        }
     350    }
     351    psFree(ncImg);
     352    psFree(ncImg2);
     353    psFree(ncImg3);
     354
     355    psFree(c64Img);
     356    psFree(c64Img2);
     357    psFree(c64Img3);
     358
     359    // Perform psImageReal with null input
     360    if(psImageReal(NULL,NULL) != NULL ) {
     361        psError(PS_ERR_UNKNOWN,true,"psImageReal did not return null with null input");
     362        return 10;
     363    }
     364
     365    // Perform psImageImaginary with null input
     366    if(psImageImaginary(NULL,NULL) != NULL ) {
     367        psError(PS_ERR_UNKNOWN,true,"psImageImaginary did not return null with null input");
     368        return 10;
     369    }
     370
    273371    return 0;
    274372}
    … …  
    279377    psImage* img2 = NULL;
    280378    psImage* img3 = NULL;
     379    psImage* c64Img = NULL;
     380    psImage* c64Img2 = NULL;
     381    psImage* c64Img3 = NULL;
     382    psImage* pImg = NULL;
     383    psImage* pImg2 = NULL;
     384    psImage* pImg3 = NULL;
     385
    281386    psU32 m = 128;
    282387    psU32 n = 64;
    … …  
    301406    GENIMAGE(img,m,n,F32,row);
    302407    GENIMAGE(img2,m,n,F32,col);
     408    GENIMAGE(c64Img,m,n,F64,row);
     409    GENIMAGE(c64Img2,m,n,F64,col);
     410    GENIMAGE(pImg,m,n,S16,row);
     411    GENIMAGE(pImg2,m,n,S16,col);
    303412
    304413    // 2. call psImageComplex
    305414    img3 = psImageComplex(img3,img,img2);
     415    c64Img3 = psImageComplex(c64Img3,c64Img,c64Img2);
    306416
    307417    // 3. verify that the result is a psC32
    … …  
    311421        return 1;
    312422    }
     423    if (c64Img3->type.type != PS_TYPE_C64) {
     424        psError(PS_ERR_UNKNOWN,true,"Image type from psImageComplex is not complex");
     425        return 10;
     426    }
    313427
    314428    // 4. call psImageReal and psImageImaginary on step 2 results (not needed, just use crealf/cimagf)
    … …  
    316430    for (psU32 row=0;row<n;row++) {
    317431        psC32* img3Row = img3->data.C32[row];
     432        psC64* c64Img3Row = c64Img3->data.C64[row];
    318433        for (psU32 col=0;col<m;col++) {
    319434            if (fabsf(crealf(img3Row[col]) - row) > FLT_EPSILON ||
    … …  
    322437                        col,row,crealf(img3Row[col]),cimagf(img3Row[col]));
    323438                return 2;
     439            }
     440            if (fabsf(crealf(c64Img3Row[col]) - row) > FLT_EPSILON ||
     441                    fabsf(cimagf(c64Img3Row[col]) - col) > FLT_EPSILON) {
     442                psError(PS_ERR_UNKNOWN,true,"psImageComplex result is invalid");
     443                return 3;
    324444            }
    325445        }
    … …  
    351471    }
    352472
     473    // Perform psImageComplex with invalid type
     474    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     475    pImg3 = psImageComplex(pImg3,pImg,pImg2);
     476    if ( pImg3 != NULL) {
     477        psError(PS_ERR_UNKNOWN,true,"psImageComplex did not return NULL");
     478        return 50;
     479    }
     480
    353481    psFree(img);
    354482    psFree(img2);
    355483    psFree(img3);
     484    psFree(c64Img);
     485    psFree(c64Img2);
     486    psFree(c64Img3);
     487    psFree(pImg);
     488    psFree(pImg2);
     489
     490    // Perform psImageComplex with null input
     491    if(psImageComplex(NULL,NULL,NULL) != NULL ) {
     492        psError(PS_ERR_UNKNOWN,true,"psImageComplex did not return null with null input");
     493        return 20;
     494    }
    356495
    357496    return 0;
    … …  
    362501    psImage* img = NULL;
    363502    psImage* img2 = NULL;
     503    psImage* c64Img = NULL;
     504    psImage* c64Img2 = NULL;
     505    psImage* pImg = NULL;
     506    psImage* pImg2 = NULL;
     507
    364508    psU32 m = 128;
    365509    psU32 n = 64;
    … …  
    374518    // 1. create a psC32 with unique real and imaginary values.
    375519    GENIMAGE(img,m,n,C32, row + I * col);
     520    GENIMAGE(c64Img,m,n,C64,row + I*col);
     521    GENIMAGE(pImg,m,n,F32,row+col);
    376522
    377523    // 2. call psImageConjugate
    378524    img2 = psImageConjugate(img2,img);
     525    c64Img2 = psImageConjugate(c64Img2,c64Img);
     526    pImg2 = psImageConjugate(pImg2,pImg);
    379527
    380528    // 3. verify result is psC32
    … …  
    383531        return 1;
    384532    }
     533    if (c64Img2->type.type != PS_TYPE_C64) {
     534        psError(PS_ERR_UNKNOWN,true,"psImageConjugate did not return a C64 image");
     535        return 10;
     536    }
     537    if (pImg2->type.type != PS_TYPE_F32) {
     538        psError(PS_ERR_UNKNOWN,true,"psImageConjugate did not return a F32 image");
     539        return 11;
     540    }
    385541
    386542    // 4. verify each value is conjugate of input (a+bi -> a-bi)
    387543    for (psU32 row=0;row<n;row++) {
    388544        psC32* img2Row = img2->data.C32[row];
     545        psC64* c64Img2Row = c64Img2->data.C64[row];
     546        psF32* pImg2Row = pImg2->data.F32[row];
    389547        for (psU32 col=0;col<m;col++) {
    390548            if (fabsf(crealf(img2Row[col]) - row) > FLT_EPSILON ||
    … …  
    394552                return 2;
    395553            }
     554            if (fabsf(crealf(c64Img2Row[col]) - row) > FLT_EPSILON ||
     555                    fabsf(cimagf(c64Img2Row[col]) + col) > FLT_EPSILON) {
     556                psError(PS_ERR_UNKNOWN,true,"psImageComplex result is invalid");
     557                return 20;
     558            }
     559            if (fabsf(pImg2Row[col] - (row+col)) > FLT_EPSILON) {
     560                psError(PS_ERR_UNKNOWN,true,"psImageComplex result is invalid");
     561                return 21;
     562            }
    396563        }
    397564    }
    … …  
    399566    psFree(img);
    400567    psFree(img2);
     568    psFree(c64Img);
     569    psFree(c64Img2);
     570    psFree(pImg);
     571    psFree(pImg2);
     572
     573    // Perform psImageConjugate with null input
     574    if(psImageConjugate(NULL,NULL) != NULL ) {
     575        psError(PS_ERR_UNKNOWN,true,"psImageConjugate did not return null with null input");
     576        return 30;
     577    }
    401578
    402579    return 0;
    … …  
    407584    psImage* img = NULL;
    408585    psImage* img2 = NULL;
     586    psImage* c64Img = NULL;
     587    psImage* c64Img2 = NULL;
     588    psImage* pImg = NULL;
     589
    409590    psU32 m = 128;
    410591    psU32 n = 64;
    … …  
    419600    // 1. create a psC32 vector with unique real and imaginary components
    420601    GENIMAGE(img,m,n,C32, row + I * col);
     602    GENIMAGE(c64Img,m,n,C64,row+I*col);
     603    GENIMAGE(pImg,m,n,F32,row+col);
    421604
    422605    // 2. call psImagePowerSpectrum
    423606    img2 = psImagePowerSpectrum(img2,img);
     607    c64Img2 = psImagePowerSpectrum(c64Img2, c64Img);
    424608
    425609    // 3. verify result is psF32
    … …  
    428612        return 1;
    429613    }
     614    if (c64Img2->type.type != PS_TYPE_F64) {
     615        psError(PS_ERR_UNKNOWN,true,"psImagePowerSpectrum did not return PS_TYPE_F64");
     616        return 10;
     617    }
    430618
    431619    // 4. verify the values are the square of the absolute values of the original
    … …  
    433621        psC32* imgRow = img->data.C32[row];
    434622        psF32* img2Row = img2->data.F32[row];
     623        psC64* c64ImgRow = c64Img->data.C64[row];
     624        psF64* c64Img2Row = c64Img2->data.F64[row];
    435625        for (psU32 col=0;col<m;col++) {
    436626            psF32 power = cabs(imgRow[col]);
     627            psF64 power64 = cabs(c64ImgRow[col]);
    437628            power *= power/n/n/m/m;
     629            power64 *= power64/n/n/m/m;
    438630
    439631            if (fabsf(img2Row[col] - power) > 2.0f*FLT_EPSILON) {
    … …  
    442634                return 2;
    443635            }
     636            if (fabsf(c64Img2Row[col] - power64) > 2.0f*FLT_EPSILON) {
     637                psError(PS_ERR_UNKNOWN,true,"psImagePowerSpectrum result is invalid");
     638                return 22;
     639            }
    444640        }
    445641    }
    … …  
    447643    psFree(img);
    448644    psFree(img2);
     645    psFree(c64Img);
     646    psFree(c64Img2);
     647
     648    // Perform psImagePowerSpectrum with invalid input
     649    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message.");
     650    if(psImagePowerSpectrum(NULL,pImg) != NULL ) {
     651        psError(PS_ERR_UNKNOWN,true,"psImagePowerSpectrum did not return null with invalid type");
     652        return 41;
     653    }
     654    psFree(pImg);
     655
     656    // Perform psImagePowerSpectrum with null input
     657    if(psImagePowerSpectrum(NULL,NULL) != NULL ) {
     658        psError(PS_ERR_UNKNOWN,true,"psImagePowerSpectrum did not return null with null input");
     659        return 40;
     660    }
    449661
    450662    return 0;

  • trunk/psLib/test/image/verified/tst_psImageFFT.stderr

    r2279 r2714  
    4343<DATE><TIME>|<HOST>|E|psImageComplex (psImageFFT.c:<LINENO>)
    4444    Real psImage size (128x64) and imaginary psImage size (64x64) must be the same.
     45<DATE><TIME>|<HOST>|I|testImageComplex
     46    Following should generate an error message.
     47<DATE><TIME>|<HOST>|E|psImageComplex (psImageFFT.c:<LINENO>)
     48    Input psImage type, psS16, is required to be either psF32 or psF64.
    4549
    4650---> TESTPOINT PASSED (psFFT{psImageComplex} | tst_psImageFFT.c)
    … …  
    6165\**********************************************************************************/
    6266
     67<DATE><TIME>|<HOST>|I|testImagePowerSpectrum
     68    Following should generate error message.
     69<DATE><TIME>|<HOST>|E|psImagePowerSpectrum (psImageFFT.c:<LINENO>)
     70    Input psImage type, psF32, is required to be either psC32 or psC64.
    6371
    6472---> TESTPOINT PASSED (psFFT{psImagePowerSpectrum} | tst_psImageFFT.c)
Note: See TracChangeset for help on using the changeset viewer.