IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 18, 2008, 2:26:45 PM (18 years ago)
Author:
beaumont
Message:

Updates to psastro to include plotting calls

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/cnb_branch_20081011/psastro/src/psastroAstromGuess.c

    r19977 r20263  
    2929    psMetadata *recipe  = psMetadataLookupPtr (NULL, config->recipes, PSASTRO_RECIPE);
    3030    if (!recipe) {
    31         psError(PSASTRO_ERR_CONFIG, true, "Can't find PSASTRO recipe!");
    32         return false;
     31        psError(PSASTRO_ERR_CONFIG, true, "Can't find PSASTRO recipe!");
     32        return false;
    3333    }
    3434
     
    3636    bool useModel = psMetadataLookupBool (&status, config->arguments, "PSASTRO.USE.MODEL");
    3737    if (!status) {
    38         useModel = psMetadataLookupBool (&status, recipe, "PSASTRO.USE.MODEL");
     38        useModel = psMetadataLookupBool (&status, recipe, "PSASTRO.USE.MODEL");
    3939    }
    4040
     
    4242    pmFPAfile *input = psMetadataLookupPtr (NULL, config->files, "PSASTRO.INPUT");
    4343    if (!input) {
    44         psError(PSASTRO_ERR_CONFIG, true, "Can't find input data");
    45         return false;
     44        psError(PSASTRO_ERR_CONFIG, true, "Can't find input data");
     45        return false;
    4646    }
    4747
     
    4949    double pixelScale = psMetadataLookupF32 (&status, recipe, "PSASTRO.PIXEL.SCALE");
    5050    if (!status) {
    51         psError(PS_ERR_IO, true, "Failed to lookup pixel scale");
    52         return false;
    53     } 
     51        psError(PS_ERR_IO, true, "Failed to lookup pixel scale");
     52        return false;
     53    }
    5454
    5555    psVector *cornerL = psVectorAllocEmpty (100, PS_TYPE_F32);
     
    6767    bool bilevelAstrometry = false;
    6868    if (!useModel) {
    69         psastroAstromGuessSetFPA (fpa, &bilevelAstrometry);
     69        psastroAstromGuessSetFPA (fpa, &bilevelAstrometry);
    7070    }
    7171
     
    7575        if (!chip->process || !chip->file_exists || !chip->data_exists) { continue; }
    7676
    77         if (!useModel) {
    78             if (!psastroAstromGuessSetChip (fpa, chip, view, pixelScale, bilevelAstrometry)) continue;
    79         }
     77        if (!useModel) {
     78            if (!psastroAstromGuessSetChip (fpa, chip, view, pixelScale, bilevelAstrometry)) continue;
     79        }
    8080
    8181        if (newFPA) {
    8282            newFPA = false;
    83             while (fpa->toSky->R <        0) fpa->toSky->R += 2.0*M_PI;
    84             while (fpa->toSky->R > 2.0*M_PI) fpa->toSky->R -= 2.0*M_PI;
     83            while (fpa->toSky->R <        0) fpa->toSky->R += 2.0*M_PI;
     84            while (fpa->toSky->R > 2.0*M_PI) fpa->toSky->R -= 2.0*M_PI;
    8585            RAminSky = fpa->toSky->R - M_PI;
    8686            RAmaxSky = fpa->toSky->R + M_PI;
    8787        }
    8888
    89         // report and save the current best guess for the chip 0,0 pixel coordinates
    90         {
    91             psPlane ptCH, ptFP, ptTP;
    92             psSphere ptSky;
    93 
    94             ptCH.x = 0;
    95             ptCH.y = 0;
    96             psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
    97             psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
    98             psDeproject (&ptSky, &ptTP, fpa->toSky);
    99             psLogMsg ("psastro", 3, "0,0 pix for chip %3d = %f,%f\n", view->chip, DEG_RAD*ptSky.r, DEG_RAD*ptSky.d);
    100 
    101             psVectorAppend (cornerL, ptFP.x);
    102             psVectorAppend (cornerM, ptFP.y);
    103             psVectorAppend (cornerP, ptTP.x);
    104             psVectorAppend (cornerQ, ptTP.y);
    105             psVectorAppend (cornerR, ptSky.r);
    106             psVectorAppend (cornerD, ptSky.d);
    107         }
     89        // report and save the current best guess for the chip 0,0 pixel coordinates
     90        {
     91            psPlane ptCH, ptFP, ptTP;
     92            psSphere ptSky;
     93
     94            ptCH.x = 0;
     95            ptCH.y = 0;
     96            psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
     97            psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
     98            psDeproject (&ptSky, &ptTP, fpa->toSky);
     99            psLogMsg ("psastro", 3, "0,0 pix for chip %3d = %f,%f\n", view->chip, DEG_RAD*ptSky.r, DEG_RAD*ptSky.d);
     100
     101            psVectorAppend (cornerL, ptFP.x);
     102            psVectorAppend (cornerM, ptFP.y);
     103            psVectorAppend (cornerP, ptTP.x);
     104            psVectorAppend (cornerQ, ptTP.y);
     105            psVectorAppend (cornerR, ptSky.r);
     106            psVectorAppend (cornerD, ptSky.d);
     107        }
    108108
    109109        // apply the new WCS guess data to all of the data in the readouts
     
    119119                if (rawstars == NULL) { continue; }
    120120
    121                 *nStars += rawstars->n;
     121                *nStars += rawstars->n;
    122122                for (int i = 0; i < rawstars->n; i++) {
    123123                    pmAstromObj *raw = rawstars->data[i];
     
    138138                }
    139139
    140                 // dump or plot the resulting projected positions
    141                 if (psTraceGetLevel("psastro.dump") > 0) {
    142                     psastroDumpRawstars (rawstars, fpa, chip);
    143                 }
    144 
    145                 if (psTraceGetLevel("psastro.plot") > 0) {
    146                     psastroPlotRawstars (rawstars, fpa, chip, recipe);
    147                 }
     140                // dump or plot the resulting projected positions
     141                if (psTraceGetLevel("psastro.dump") > 0) {
     142                    psastroDumpRawstars (rawstars, fpa, chip);
     143                }
     144
     145                psastroVisualPlotRawStars(rawstars, fpa, chip, recipe);
     146
     147                if (psTraceGetLevel("psastro.plot") > 0) {
     148                    psastroPlotRawstars (rawstars, fpa, chip, recipe);
     149                }
    148150            }
    149151        }
     
    155157    psMetadataAddS32 (recipe, PS_LIST_TAIL, "NTOTSTAR",  PS_META_REPLACE, "", *nStars);
    156158    if (*nStars == 0) {
    157         psLogMsg ("psastro", 2, "no sources available for astrometry\n");
    158         psFree (view);
    159         return true;
    160     }
    161 
    162     psLogMsg ("psastro", 2, "loaded raw data from %f,%f to %f,%f\n", 
    163               DEG_RAD*RAmin, DEG_RAD*DECmin,
    164               DEG_RAD*RAmax, DEG_RAD*DECmax);
     159        psLogMsg ("psastro", 2, "no sources available for astrometry\n");
     160        psFree (view);
     161        return true;
     162    }
     163
     164    psLogMsg ("psastro", 2, "loaded raw data from %f,%f to %f,%f\n",
     165              DEG_RAD*RAmin, DEG_RAD*DECmin,
     166              DEG_RAD*RAmax, DEG_RAD*DECmax);
    165167
    166168    psMetadataAddF32 (recipe, PS_LIST_TAIL, "RA_MIN",  PS_META_REPLACE, "", RAmin);
     
    201203    pmHDU *hdu = pmFPAviewThisHDU (view, fpa);
    202204    if (bilevelAstrometry) {
    203         if (!pmAstromReadBilevelChip (chip, hdu->header)) {
    204             psWarning("Could not get WCS information from header for chip %d, skipping", view->chip);
    205             return false;
    206         }
     205        if (!pmAstromReadBilevelChip (chip, hdu->header)) {
     206            psWarning("Could not get WCS information from header for chip %d, skipping", view->chip);
     207            return false;
     208        }
    207209    } else {
    208         if (!pmAstromReadWCS (fpa, chip, hdu->header, pixelScale)) {
    209             psWarning("Could not get WCS information from header for chip %d, skipping", view->chip);
    210             return false;
    211         }
     210        if (!pmAstromReadWCS (fpa, chip, hdu->header, pixelScale)) {
     211            psWarning("Could not get WCS information from header for chip %d, skipping", view->chip);
     212            return false;
     213        }
    212214    }
    213215    return true;
     
    223225    // load mosaic-level astrometry?
    224226    if (phu) {
    225         char *ctype = psMetadataLookupStr (NULL, phu->header, "CTYPE1");
    226         if (ctype) {
    227             *bilevelAstrometry = !strcmp (&ctype[4], "-DIS");
    228         }
     227        char *ctype = psMetadataLookupStr (NULL, phu->header, "CTYPE1");
     228        if (ctype) {
     229            *bilevelAstrometry = !strcmp (&ctype[4], "-DIS");
     230        }
    229231    }
    230232    if (*bilevelAstrometry) {
    231         pmAstromReadBilevelMosaic (fpa, phu->header);
    232     } 
     233        pmAstromReadBilevelMosaic (fpa, phu->header);
     234    }
    233235    psFree (view);
    234236    return true;
     
    243245    pmFPAfile *input = psMetadataLookupPtr (NULL, config->files, "PSASTRO.INPUT");
    244246    if (!input) {
    245         psError(PSASTRO_ERR_CONFIG, true, "Can't find input data");
    246         return false;
     247        psError(PSASTRO_ERR_CONFIG, true, "Can't find input data");
     248        return false;
    247249    }
    248250
     
    273275        if (!chip->process || !chip->file_exists || !chip->data_exists) { continue; }
    274276
    275         psPlane ptCH, ptFP, ptTP;
    276         psSphere ptSky;
    277 
    278         ptCH.x = 0;
    279         ptCH.y = 0;
    280         psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
    281         psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
    282         psDeproject (&ptSky, &ptTP, fpa->toSky);
    283         psLogMsg ("psastro", 3, "0,0 pix for chip %3d = %f,%f\n", view->chip, DEG_RAD*ptSky.r, DEG_RAD*ptSky.d);
    284 
    285         // new corner locations based on the calibrated astrometry
    286         psVectorAppend (cornerLn, ptFP.x);
    287         psVectorAppend (cornerMn, ptFP.y);
    288         psVectorAppend (cornerPn, ptTP.x);
    289         psVectorAppend (cornerQn, ptTP.y);
    290         psVectorAppend (cornerRn, ptSky.r);
    291         psVectorAppend (cornerDn, ptSky.d);
     277        psPlane ptCH, ptFP, ptTP;
     278        psSphere ptSky;
     279
     280        ptCH.x = 0;
     281        ptCH.y = 0;
     282        psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
     283        psPlaneTransformApply (&ptTP, fpa->toTPA, &ptFP);
     284        psDeproject (&ptSky, &ptTP, fpa->toSky);
     285        psLogMsg ("psastro", 3, "0,0 pix for chip %3d = %f,%f\n", view->chip, DEG_RAD*ptSky.r, DEG_RAD*ptSky.d);
     286
     287        // new corner locations based on the calibrated astrometry
     288        psVectorAppend (cornerLn, ptFP.x);
     289        psVectorAppend (cornerMn, ptFP.y);
     290        psVectorAppend (cornerPn, ptTP.x);
     291        psVectorAppend (cornerQn, ptTP.y);
     292        psVectorAppend (cornerRn, ptSky.r);
     293        psVectorAppend (cornerDn, ptSky.d);
    292294    }
    293295
     
    298300
    299301    for (int i = 0; i < cornerRo->n; i++) {
    300        
    301         psPlane ptTP;
    302         psSphere ptSky;
    303 
    304         ptSky.r = cornerRo->data.F32[i];
    305         ptSky.d = cornerDo->data.F32[i];
    306 
    307         psProject (&ptTP, &ptSky, fpa->toSky);
    308         psVectorAppend (cornerPs, ptTP.x);
    309         psVectorAppend (cornerQs, ptTP.y);
     302
     303        psPlane ptTP;
     304        psSphere ptSky;
     305
     306        ptSky.r = cornerRo->data.F32[i];
     307        ptSky.d = cornerDo->data.F32[i];
     308
     309        psProject (&ptTP, &ptSky, fpa->toSky);
     310        psVectorAppend (cornerPs, ptTP.x);
     311        psVectorAppend (cornerQs, ptTP.y);
    310312    }
    311313
     
    313315    map->x->coeffMask[1][1] = PS_POLY_MASK_SET;
    314316    map->y->coeffMask[1][1] = PS_POLY_MASK_SET;
    315    
     317
    316318    psVectorFitPolynomial2D (map->x, NULL, 0, cornerPn, NULL, cornerPs, cornerQs);
    317319    psVectorFitPolynomial2D (map->y, NULL, 0, cornerQn, NULL, cornerPs, cornerQs);
    318    
     320
    319321    // apply the linear fit...
    320322    psVector *cornerPf = psPolynomial2DEvalVector (map->x, cornerPs, cornerQs);
     
    325327    psVector *cornerQd = (psVector *) psBinaryOp (NULL, cornerQn, "-", cornerQf);
    326328
     329    psastroVisualPlotAstromGuessCheck (cornerPo, cornerQo, cornerPn, cornerQn, cornerPd, cornerQd);
     330
    327331    psStats *statsP = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
    328332    psStats *statsQ = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
     
    333337    float angle = atan2 (map->y->coeff[1][0], map->x->coeff[1][0]);
    334338    float scale = hypot (map->y->coeff[1][0], map->x->coeff[1][0]);
    335    
     339
    336340    psLogMsg ("psastro", 3, "boresite offset  : %f,%f\n", map->x->coeff[0][0], map->y->coeff[0][0]);
    337341    psLogMsg ("psastro", 3, "boresite angle   : %f, scale: %f", angle*PS_DEG_RAD, scale);
     
    341345    psMetadata *header = psMetadataLookupMetadata (&status, input->fpa->analysis, "PSASTRO.HEADER");
    342346    if (!header) {
    343         header = psMetadataAlloc();
    344         psMetadataAddMetadata (input->fpa->analysis, PS_LIST_TAIL, "PSASTRO.HEADER",  PS_META_REPLACE, "psastro header stats", header);
    345         psFree (header);  // drop this reference
     347        header = psMetadataAlloc();
     348        psMetadataAddMetadata (input->fpa->analysis, PS_LIST_TAIL, "PSASTRO.HEADER",  PS_META_REPLACE, "psastro header stats", header);
     349        psFree (header);  // drop this reference
    346350    }
    347351
     
    354358
    355359    if (0) {
    356         FILE *f = fopen ("corners.dat", "w");
    357         for (int i = 0; i < cornerRo->n; i++) {
    358             fprintf (f, "%10.6f %10.6f  %9.2f %9.2f  %9.2f %9.2f  |  %10.6f %10.6f  %9.2f %9.2f  %9.2f %9.2f\n",
    359                      cornerRn->data.F32[i], cornerDn->data.F32[i], cornerPn->data.F32[i], cornerQn->data.F32[i], cornerLn->data.F32[i], cornerMn->data.F32[i],
    360                      cornerRo->data.F32[i], cornerDo->data.F32[i], cornerPo->data.F32[i], cornerQo->data.F32[i], cornerLo->data.F32[i], cornerMo->data.F32[i]);
    361         }
    362         fclose (f);
     360        FILE *f = fopen ("corners.dat", "w");
     361        for (int i = 0; i < cornerRo->n; i++) {
     362            fprintf (f, "%10.6f %10.6f  %9.2f %9.2f  %9.2f %9.2f  |  %10.6f %10.6f  %9.2f %9.2f  %9.2f %9.2f\n",
     363                     cornerRn->data.F32[i], cornerDn->data.F32[i], cornerPn->data.F32[i], cornerQn->data.F32[i], cornerLn->data.F32[i], cornerMn->data.F32[i],
     364                     cornerRo->data.F32[i], cornerDo->data.F32[i], cornerPo->data.F32[i], cornerQo->data.F32[i], cornerLo->data.F32[i], cornerMo->data.F32[i]);
     365        }
     366        fclose (f);
    363367    }
    364368
     
    381385    psFree (map);
    382386    psFree (view);
    383    
     387
    384388
    385389    return true;
Note: See TracChangeset for help on using the changeset viewer.