IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 13, 2006, 8:25:29 PM (20 years ago)
Author:
magnier
Message:

more tests of mosaic astrometry

Location:
trunk/psModules/test/astrom
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/test/astrom

    • Property svn:ignore

      •  

        old new  
        88tap_pmAstrometryWCS
        99tap_pmAstrometryWCS_DVO2
         10tap_pmAstrometryWCS_DVO3

  • trunk/psModules/test/astrom/tap_pmAstrometryWCS_DVO.c

    r10645 r10711  
    1818void test3(); // 2nd order term
    1919
     20void test1in(); // basic TAN projection,
     21void test2in(); // small rotation
     22void test3in(); // 2nd order term
     23
    2024void testA(); // alloc test
    2125void testB(); // alloc test
    … …  
    2327int main (void)
    2428{
    25     plan_tests(492);
     29    plan_tests(984);
    2630
    2731    diag("pmAstrometryWCS tests compared with DVO coords routines");
     32    diag("this file tests pmAstromWCS <-> Header representations");
     33
     34    test1in();
     35    test2in();
     36    test3in();
    2837
    2938    test1();
    … …  
    3342}
    3443
    35 void test3 ()
    36 {
    37     diag("test pmAstromReadWCS");
     44void test3in()
     45{
     46    diag("test pmAstromWCStoHeader");
    3847    psMemId id = psMemGetId();
    3948
    … …  
    5968    coords.polyterms[2][1] = 0.01; // M vs Y^2
    6069
    61     psMetadata *header = WriteCoordsToHeader (&coords);
    62     pmAstromWCS *wcs = pmAstromWCSfromHeader (header);
    63 
    64     ok (wcs != NULL, "converted WCS keywords to WCS astrometry");
    65     skip_start (wcs == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
    66 
    67     psSphere *sky = psSphereAlloc();
    68     psPlane *chip = psPlaneAlloc();
    69 
    70     double rDVO, dDVO;
     70    psMetadata *header1 = WriteCoordsToHeader(&coords);
     71    pmAstromWCS *wcs1 = pmAstromWCSfromHeader(header1);
     72    skip_start (wcs1 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     73
     74    psMetadata *header2 = psMetadataAlloc();
     75    pmAstromWCStoHeader(header2, wcs1);
     76    pmAstromWCS *wcs2 = pmAstromWCSfromHeader(header2);
     77
     78    psMetadataConfigWrite (header1, "head1.md");
     79    psMetadataConfigWrite (header2, "head2.md");
     80
     81    ok (wcs2 != NULL, "converted WCS keywords to WCS astrometry");
     82    skip_start (wcs2 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     83
     84    psSphere *sky1 = psSphereAlloc();
     85    psSphere *sky2 = psSphereAlloc();
     86    psPlane *chip = psPlaneAlloc();
     87
    7188    for (double x = -2000; x <= +2000; x+= 500.0) {
    7289        for (double y = -2000; y <= +2000; y+= 500.0) {
    73             XY_to_RD (&rDVO, &dDVO, x, y, &coords);
    7490            chip->x = x;
    7591            chip->y = y;
    76             pmAstromWCStoSky (sky, wcs, chip);
    77             while (sky->r > 2*M_PI)
    78                 sky->r -= 2*M_PI;
    79             while (sky->r <      0)
    80                 sky->r += 2*M_PI;
    81 
    82             ok_float(rDVO, sky->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", rDVO, sky->r*PM_DEG_RAD, rDVO - sky->r*PM_DEG_RAD);
    83             ok_float(dDVO, sky->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", dDVO, sky->d*PM_DEG_RAD, dDVO - sky->d*PM_DEG_RAD);
     92            pmAstromWCStoSky (sky1, wcs1, chip);
     93            pmAstromWCStoSky (sky2, wcs2, chip);
     94            while (sky1->r > 2*M_PI)
     95                sky1->r -= 2*M_PI;
     96            while (sky1->r <      0)
     97                sky1->r += 2*M_PI;
     98            while (sky2->r > 2*M_PI)
     99                sky2->r -= 2*M_PI;
     100            while (sky2->r <      0)
     101                sky2->r += 2*M_PI;
     102
     103            ok_float(sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, sky1->r*PM_DEG_RAD - sky2->r*PM_DEG_RAD);
     104            ok_float(sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, sky1->d*PM_DEG_RAD - sky2->d*PM_DEG_RAD);
    84105        }
    85106    }
    86     psFree (sky);
    87     psFree (chip);
    88 
    89     skip_end();
    90     psFree (wcs);
    91     psFree (header);
    92 
    93     ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
    94 }
    95 
    96 void test2 ()
    97 {
    98     diag("test pmAstromReadWCS");
     107    psFree (sky1);
     108    psFree (sky2);
     109    psFree (chip);
     110
     111    skip_end();
     112    psFree (wcs2);
     113    psFree (header2);
     114
     115    skip_end();
     116    psFree (wcs1);
     117    psFree (header1);
     118
     119    ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
     120}
     121
     122void test2in()
     123{
     124    diag("test pmAstromWCStoHeader");
    99125    psMemId id = psMemGetId();
    100126
    … …  
    118144    }
    119145
    120     psMetadata *header = WriteCoordsToHeader (&coords);
    121     pmAstromWCS *wcs = pmAstromWCSfromHeader (header);
    122 
    123     ok (wcs != NULL, "converted WCS keywords to WCS astrometry");
    124     skip_start (wcs == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
    125 
    126     psSphere *sky = psSphereAlloc();
    127     psPlane *chip = psPlaneAlloc();
    128 
    129     double rDVO, dDVO;
     146    psMetadata *header1 = WriteCoordsToHeader(&coords);
     147    pmAstromWCS *wcs1 = pmAstromWCSfromHeader(header1);
     148    skip_start (wcs1 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     149
     150    psMetadata *header2 = psMetadataAlloc();
     151    pmAstromWCStoHeader(header2, wcs1);
     152    pmAstromWCS *wcs2 = pmAstromWCSfromHeader(header2);
     153
     154    psMetadataConfigWrite (header1, "head1.md");
     155    psMetadataConfigWrite (header2, "head2.md");
     156
     157    ok (wcs2 != NULL, "converted WCS keywords to WCS astrometry");
     158    skip_start (wcs2 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     159
     160    psSphere *sky1 = psSphereAlloc();
     161    psSphere *sky2 = psSphereAlloc();
     162    psPlane *chip = psPlaneAlloc();
     163
    130164    for (double x = -2000; x <= +2000; x+= 500.0) {
    131165        for (double y = -2000; y <= +2000; y+= 500.0) {
    132             XY_to_RD (&rDVO, &dDVO, x, y, &coords);
    133166            chip->x = x;
    134167            chip->y = y;
    135             pmAstromWCStoSky (sky, wcs, chip);
    136             while (sky->r > 2*M_PI)
    137                 sky->r -= 2*M_PI;
    138             while (sky->r <      0)
    139                 sky->r += 2*M_PI;
    140 
    141             ok_float(rDVO, sky->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", rDVO, sky->r*PM_DEG_RAD, rDVO - sky->r*PM_DEG_RAD);
    142             ok_float(dDVO, sky->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", dDVO, sky->d*PM_DEG_RAD, dDVO - sky->d*PM_DEG_RAD);
     168            pmAstromWCStoSky (sky1, wcs1, chip);
     169            pmAstromWCStoSky (sky2, wcs2, chip);
     170            while (sky1->r > 2*M_PI)
     171                sky1->r -= 2*M_PI;
     172            while (sky1->r <      0)
     173                sky1->r += 2*M_PI;
     174            while (sky2->r > 2*M_PI)
     175                sky2->r -= 2*M_PI;
     176            while (sky2->r <      0)
     177                sky2->r += 2*M_PI;
     178
     179            ok_float(sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, sky1->r*PM_DEG_RAD - sky2->r*PM_DEG_RAD);
     180            ok_float(sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, sky1->d*PM_DEG_RAD - sky2->d*PM_DEG_RAD);
    143181        }
    144182    }
    145     psFree (sky);
    146     psFree (chip);
    147 
    148     skip_end();
    149     psFree (wcs);
    150     psFree (header);
    151 
    152     ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
    153 }
    154 
    155 void test1()
    156 {
    157     diag("test pmAstromReadWCS");
     183    psFree (sky1);
     184    psFree (sky2);
     185    psFree (chip);
     186
     187    skip_end();
     188    psFree (wcs2);
     189    psFree (header2);
     190
     191    skip_end();
     192    psFree (wcs1);
     193    psFree (header1);
     194
     195    ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
     196}
     197
     198void test1in()
     199{
     200    diag("test pmAstromWCStoHeader");
    158201    psMemId id = psMemGetId();
    159202
    … …  
    177220    }
    178221
     222    psMetadata *header1 = WriteCoordsToHeader(&coords);
     223    pmAstromWCS *wcs1 = pmAstromWCSfromHeader(header1);
     224    skip_start (wcs1 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     225
     226    psMetadata *header2 = psMetadataAlloc();
     227    pmAstromWCStoHeader(header2, wcs1);
     228    pmAstromWCS *wcs2 = pmAstromWCSfromHeader(header2);
     229
     230    ok (wcs2 != NULL, "converted WCS keywords to WCS astrometry");
     231    skip_start (wcs2 == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     232
     233    psSphere *sky1 = psSphereAlloc();
     234    psSphere *sky2 = psSphereAlloc();
     235    psPlane *chip = psPlaneAlloc();
     236
     237    for (double x = -2000; x <= +2000; x+= 500.0) {
     238        for (double y = -2000; y <= +2000; y+= 500.0) {
     239            chip->x = x;
     240            chip->y = y;
     241            pmAstromWCStoSky (sky1, wcs1, chip);
     242            pmAstromWCStoSky (sky2, wcs2, chip);
     243            while (sky1->r > 2*M_PI)
     244                sky1->r -= 2*M_PI;
     245            while (sky1->r <      0)
     246                sky1->r += 2*M_PI;
     247            while (sky2->r > 2*M_PI)
     248                sky2->r -= 2*M_PI;
     249            while (sky2->r <      0)
     250                sky2->r += 2*M_PI;
     251
     252            ok_float(sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->r*PM_DEG_RAD, sky2->r*PM_DEG_RAD, sky1->r*PM_DEG_RAD - sky2->r*PM_DEG_RAD);
     253            ok_float(sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", sky1->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD, sky2->d*PM_DEG_RAD - sky2->d*PM_DEG_RAD);
     254        }
     255    }
     256    psFree (sky1);
     257    psFree (sky2);
     258    psFree (chip);
     259
     260    skip_end();
     261    psFree (wcs2);
     262    psFree (header2);
     263
     264    skip_end();
     265    psFree (wcs1);
     266    psFree (header1);
     267
     268    ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
     269}
     270
     271void test3 ()
     272{
     273    diag("test pmAstromWCSfromHeader ");
     274    psMemId id = psMemGetId();
     275
     276    // build a DVO-style coordinate system
     277    Coords coords;
     278    strcpy (coords.ctype, "RA---TAN");
     279    coords.crval1 = 0.0;
     280    coords.crval2 = 0.0;
     281    coords.crpix1 = 0.0;
     282    coords.crpix2 = 0.0;
     283    coords.cdelt1 = 1.0/3600;
     284    coords.cdelt2 = 1.0/3600;
     285    coords.pc1_1  = 1.0;
     286    coords.pc1_2  = 0.0;
     287    coords.pc2_1  = 0.0;
     288    coords.pc2_2  = 1.0;
     289    coords.Npolyterms = 2;
     290    for (int i = 0; i < 7; i++) {
     291        coords.polyterms[i][0] = 0.0;
     292        coords.polyterms[i][1] = 0.0;
     293    }
     294    coords.polyterms[0][0] = 0.01; // L vs X^2
     295    coords.polyterms[2][1] = 0.01; // M vs Y^2
     296
     297    psMetadata *header = WriteCoordsToHeader (&coords);
     298    pmAstromWCS *wcs = pmAstromWCSfromHeader (header);
     299
     300    ok (wcs != NULL, "converted WCS keywords to WCS astrometry");
     301    skip_start (wcs == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     302
     303    psSphere *sky = psSphereAlloc();
     304    psPlane *chip = psPlaneAlloc();
     305
     306    double rDVO, dDVO;
     307    for (double x = -2000; x <= +2000; x+= 500.0) {
     308        for (double y = -2000; y <= +2000; y+= 500.0) {
     309            XY_to_RD (&rDVO, &dDVO, x, y, &coords);
     310            chip->x = x;
     311            chip->y = y;
     312            pmAstromWCStoSky (sky, wcs, chip);
     313            while (sky->r > 2*M_PI)
     314                sky->r -= 2*M_PI;
     315            while (sky->r <      0)
     316                sky->r += 2*M_PI;
     317
     318            ok_float(rDVO, sky->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", rDVO, sky->r*PM_DEG_RAD, rDVO - sky->r*PM_DEG_RAD);
     319            ok_float(dDVO, sky->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", dDVO, sky->d*PM_DEG_RAD, dDVO - sky->d*PM_DEG_RAD);
     320        }
     321    }
     322    psFree (sky);
     323    psFree (chip);
     324
     325    skip_end();
     326    psFree (wcs);
     327    psFree (header);
     328
     329    ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
     330}
     331
     332void test2 ()
     333{
     334    diag("test pmAstromWCSfromHeader");
     335    psMemId id = psMemGetId();
     336
     337    // build a DVO-style coordinate system
     338    Coords coords;
     339    strcpy (coords.ctype, "RA---TAN");
     340    coords.crval1 = 0.0;
     341    coords.crval2 = 0.0;
     342    coords.crpix1 = 0.0;
     343    coords.crpix2 = 0.0;
     344    coords.cdelt1 = 1.0/3600;
     345    coords.cdelt2 = 1.0/3600;
     346    coords.pc1_1  = 0.9;
     347    coords.pc1_2  = -0.1;
     348    coords.pc2_1  = 0.1;
     349    coords.pc2_2  = 0.9;
     350    coords.Npolyterms = 0;
     351    for (int i = 0; i < 7; i++) {
     352        coords.polyterms[i][0] = 0.0;
     353        coords.polyterms[i][1] = 0.0;
     354    }
     355
     356    psMetadata *header = WriteCoordsToHeader (&coords);
     357    pmAstromWCS *wcs = pmAstromWCSfromHeader (header);
     358
     359    ok (wcs != NULL, "converted WCS keywords to WCS astrometry");
     360    skip_start (wcs == NULL, 1, "*** WCS Conversion FAILS *** : skipping related tests");
     361
     362    psSphere *sky = psSphereAlloc();
     363    psPlane *chip = psPlaneAlloc();
     364
     365    double rDVO, dDVO;
     366    for (double x = -2000; x <= +2000; x+= 500.0) {
     367        for (double y = -2000; y <= +2000; y+= 500.0) {
     368            XY_to_RD (&rDVO, &dDVO, x, y, &coords);
     369            chip->x = x;
     370            chip->y = y;
     371            pmAstromWCStoSky (sky, wcs, chip);
     372            while (sky->r > 2*M_PI)
     373                sky->r -= 2*M_PI;
     374            while (sky->r <      0)
     375                sky->r += 2*M_PI;
     376
     377            ok_float(rDVO, sky->r*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", rDVO, sky->r*PM_DEG_RAD, rDVO - sky->r*PM_DEG_RAD);
     378            ok_float(dDVO, sky->d*PM_DEG_RAD, "coordinate match: %f vs %f (delta = %f)", dDVO, sky->d*PM_DEG_RAD, dDVO - sky->d*PM_DEG_RAD);
     379        }
     380    }
     381    psFree (sky);
     382    psFree (chip);
     383
     384    skip_end();
     385    psFree (wcs);
     386    psFree (header);
     387
     388    ok(!psMemCheckLeaks (id, NULL, stderr, false), "no memory leaks");
     389}
     390
     391void test1()
     392{
     393    diag("test pmAstromWCSfromHeader");
     394    psMemId id = psMemGetId();
     395
     396    // build a DVO-style coordinate system
     397    Coords coords;
     398    strcpy (coords.ctype, "RA---TAN");
     399    coords.crval1 = 0.0;
     400    coords.crval2 = 0.0;
     401    coords.crpix1 = 0.0;
     402    coords.crpix2 = 0.0;
     403    coords.cdelt1 = 1.0/3600;
     404    coords.cdelt2 = 1.0/3600;
     405    coords.pc1_1  = 1.0;
     406    coords.pc1_2  = 0.0;
     407    coords.pc2_1  = 0.0;
     408    coords.pc2_2  = 1.0;
     409    coords.Npolyterms = 0;
     410    for (int i = 0; i < 7; i++) {
     411        coords.polyterms[i][0] = 0.0;
     412        coords.polyterms[i][1] = 0.0;
     413    }
     414
    179415    psMetadata *header = WriteCoordsToHeader (&coords);
    180416    pmAstromWCS *wcs = pmAstromWCSfromHeader (header);
Note: See TracChangeset for help on using the changeset viewer.