IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 19880


Ignore:
Timestamp:
Oct 3, 2008, 10:59:38 AM (18 years ago)
Author:
eugene
Message:

adding additional plots

Location:
trunk/psphot/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psphot/src/psphot.h

    r19869 r19880  
    141141bool psphotVisualShowFootprints (pmConfig *config, const pmFPAview *view, pmDetections *detections);
    142142bool psphotVisualShowMoments (pmConfig *config, const pmFPAview *view, psArray *sources);
     143bool psphotVisualPlotMoments (pmConfig *config, const pmFPAview *view, psArray *sources);
    143144bool psphotVisualShowRoughClass (pmConfig *config, const pmFPAview *view, psArray *sources);
    144145bool psphotVisualShowPSFStars (pmConfig *config, const pmFPAview *view, pmPSF *psf, psArray *sources);
    145146bool psphotVisualShowSatStars (pmConfig *config, const pmFPAview *view, pmPSF *psf, psArray *sources);
    146 bool psphotVisualShowLinearFit (pmConfig *config, pmReadout *readout);
    147147bool psphotVisualShowPSFModel (pmConfig *config, pmReadout *readout, pmPSF *psf);
     148bool psphotVisualShowFlags (pmConfig *config, const pmFPAview *view, psArray *sources);
     149bool psphotVisualShowSourceSize (pmConfig *config, const pmFPAview *view, psArray *sources);
     150bool psphotVisualShowResidualImage (pmConfig *config, pmReadout *readout);
     151bool psphotVisualPlotApResid (pmConfig *config, psArray *sources);
    148152
    149153// structures & functions to support psf-convolved model fitting

  • trunk/psphot/src/psphotReadout.c

    r19869 r19880  
    6969    }
    7070 
    71     // display the backsub and backgnd images
     71    // display the peaks and footprints
    7272    psphotVisualShowPeaks (config, view, detections);
    7373    psphotVisualShowFootprints (config, view, detections);
    74 
    75     // XXX test write out the footprint image
    76     if (0) {
    77         psImage *footprintImage = pmSetFootprintArrayIDs (detections->footprints, true);
    78         psphotSaveImage (NULL, footprintImage, "footprints.1.fits");
    79         psFree (footprintImage);
    80     }
    8174
    8275    // construct sources and measure basic stats
    … …  
    109102
    110103    psphotVisualShowRoughClass (config, view, sources);
     104    psphotVisualShowFlags (config, view, sources);
    111105
    112106    // if we were not supplied a PSF, choose one here
    … …  
    173167    psphotVisualShowPSFStars (config, view, psf, sources);
    174168    psphotVisualShowSatStars (config, view, psf, sources);
    175     psphotVisualShowLinearFit (config, readout);
    176 
    177     if (0) {
    178         FILE *out = fopen ("out.pass1.dat", "w");
    179 
    180         for (int i = 0; i < sources->n; i++) {
    181             pmSource *source = sources->data[i];
    182             if (!source) continue;
    183             pmPeak *peak = source->peak;
    184             if (!peak) continue;
    185             pmModel *model = source->modelPSF;
    186             if (!model) continue;
    187             if (!model->params) continue;
    188 
    189             fprintf (out, "%d %f %f  %f %f  %f %f\n",
    190                      i, peak->xf, peak->yf, peak->flux, peak->SN,
    191                      model->params->data.F32[PM_PAR_I0],
    192                      model->dparams->data.F32[PM_PAR_I0]);
    193         }
    194         fclose (out);
    195     }
     169    psphotVisualShowResidualImage (config, readout);
     170    psphotVisualShowFlags (config, view, sources);
    196171
    197172    // identify CRs and extended sources
    … …  
    201176    }
    202177
    203     // XXX psphotVisualShowSourceSize (config, view, sources);
     178    psphotVisualShowSourceSize (config, view, sources);
    204179
    205180    // non-linear PSF and EXT fit to brighter sources
    206181    psphotBlendFit (readout, sources, recipe, psf);
    207182
    208     // XXX psphotVisualShowNonLinearFit (config, view, sources);
     183    psphotVisualShowResidualImage (config, readout);
     184    psphotVisualShowFlags (config, view, sources);
    209185
    210186    // replace all sources
    … …  
    213189    // linear fit to include all sources
    214190    psphotFitSourcesLinear (readout, sources, recipe, psf, TRUE);
     191
     192    psphotVisualShowResidualImage (config, readout);
     193    psphotVisualShowFlags (config, view, sources);
    215194
    216195    // if we only do one pass, skip to extended source analysis
    … …  
    231210    detections = psphotFindDetections (detections, readout, recipe);
    232211
    233     // XXX test write out the footprint image
    234     if (0) {
    235         psImage *footprintImage = pmSetFootprintArrayIDs (detections->footprints, true);
    236         psphotSaveImage (NULL, footprintImage, "footprints.2.fits");
    237         psFree (footprintImage);
    238     }
    239212    // remove noise for subtracted objects (ie, return to normal noise level)
    240213    psphotSubNoise (readout, sources, recipe);
     214
     215    // display the new peaks and footprints
     216    psphotVisualShowPeaks (config, view, detections);
     217    psphotVisualShowFootprints (config, view, detections);
    241218
    242219    // define new sources based on only the new peaks
    … …  
    249226    }
    250227
     228    psphotVisualShowRoughClass (config, view, sources);
     229    psphotVisualShowFlags (config, view, sources);
     230
    251231    // create full input models
    252232    psphotGuessModels (readout, newSources, recipe, psf);
    … …  
    262242    psphotFitSourcesLinear (readout, sources, recipe, psf, TRUE);
    263243
    264     if (0) {
    265         FILE *out = fopen ("out.pass2.dat", "w");
    266 
    267         for (int i = 0; i < sources->n; i++) {
    268             pmSource *source = sources->data[i];
    269             if (!source) continue;
    270             pmPeak *peak = source->peak;
    271             if (!peak) continue;
    272             pmModel *model = source->modelPSF;
    273             if (!model) continue;
    274             if (!model->params) continue;
    275 
    276             fprintf (out, "%d %f %f  %f %f  %f %f\n",
    277                      i, peak->xf, peak->yf, peak->flux, peak->SN,
    278                      model->params->data.F32[PM_PAR_I0],
    279                      model->dparams->data.F32[PM_PAR_I0]);
    280         }
    281         fclose (out);
    282     }
     244    psphotVisualShowResidualImage (config, readout);
     245    psphotVisualShowFlags (config, view, sources);
    283246
    284247pass1finish:
    … …  
    286249    // measure source size for the remaining sources
    287250    psphotSourceSize (config, readout, sources, recipe, 0);
    288     if (0) {
    289         psphotSaveImage (NULL, readout->mask, "mask.fits");
    290     }
    291        
     251    psphotVisualShowSourceSize (config, view, sources);
     252
    292253    psphotExtendedSourceAnalysis (readout, sources, recipe);
    293254
    … …  
    305266    }
    306267
     268    psphotVisualPlotApResid (config, sources);
     269
    307270    // calculate source magnitudes
    308271    pmReadout *background = psphotSelectBackground (config, view, false);

  • trunk/psphot/src/psphotVisual.c

    r19869 r19880  
    399399
    400400        overlay[Noverlay].type = KII_OVERLAY_CIRCLE;
    401         overlay[Noverlay].x = moments->x;
    402         overlay[Noverlay].y = moments->y;
    403 
    404         emoments.x2 = moments->Sx;
    405         emoments.y2 = moments->Sy;
    406         emoments.xy = moments->Sxy;
     401        overlay[Noverlay].x = moments->Mx;
     402        overlay[Noverlay].y = moments->My;
     403
     404        emoments.x2 = moments->Mxx;
     405        emoments.xy = moments->Mxy;
     406        emoments.y2 = moments->Myy;
    407407
    408408        axes = psEllipseMomentsToAxes (emoments, 20.0);
    … …  
    410410        overlay[Noverlay].dx = 2.0*axes.major;
    411411        overlay[Noverlay].dy = 2.0*axes.minor;
    412         overlay[Noverlay].angle = axes.theta * PS_DEG_RAD;
     412        overlay[Noverlay].angle = -axes.theta * PS_DEG_RAD;  // XXXXXXXX the axes angle is negative to display of object on kapa
    413413        overlay[Noverlay].text = NULL;
    414414        Noverlay ++;
    … …  
    488488            continue;
    489489
    490         xFaint->data.F32[nF] = source->moments->Sx;
    491         yFaint->data.F32[nF] = source->moments->Sy;
     490        xFaint->data.F32[nF] = source->moments->Mxx;
     491        yFaint->data.F32[nF] = source->moments->Myy;
    492492        nF++;
    493493
    … …  
    496496            continue;
    497497
    498         xBright->data.F32[nB] = source->moments->Sx;
    499         yBright->data.F32[nB] = source->moments->Sy;
     498        xBright->data.F32[nB] = source->moments->Mxx;
     499        yBright->data.F32[nB] = source->moments->Myy;
    500500        nB++;
    501501    }
    … …  
    613613
    614614        overlay[Noverlay].type = KII_OVERLAY_CIRCLE;
    615         overlay[Noverlay].x = moments->x;
    616         overlay[Noverlay].y = moments->y;
    617 
    618         emoments.x2 = moments->Sx;
    619         emoments.y2 = moments->Sy;
    620         emoments.xy = moments->Sxy;
     615        overlay[Noverlay].x = moments->Mx;
     616        overlay[Noverlay].y = moments->My;
     617
     618        emoments.x2 = moments->Mxx;
     619        emoments.y2 = moments->Myy;
     620        emoments.xy = moments->Mxy;
    621621
    622622        axes = psEllipseMomentsToAxes (emoments, 20.0);
    … …  
    624624        overlay[Noverlay].dx = 2.0*axes.major;
    625625        overlay[Noverlay].dy = 2.0*axes.minor;
    626         overlay[Noverlay].angle = axes.theta * PS_DEG_RAD;
     626        overlay[Noverlay].angle = -axes.theta * PS_DEG_RAD;
    627627        overlay[Noverlay].text = NULL;
    628628        Noverlay ++;
    … …  
    10141014            // XXX should we measure this for the analytical model only or the full model?
    10151015            pmModelAddWithOffset (psfMosaic, NULL, model, PM_MODEL_OP_FULL | PM_MODEL_OP_CENTER, 0, -x*DX, -y*DY);
     1016            psFree (model);
    10161017        }
    10171018    }
    … …  
    10421043    psphotVisualRangeImage (kapa2, psfLogFlux, "psf_mosaic", 1, -2.0, 3.0);
    10431044
    1044     // pause and wait for user input:
    1045     // continue, save (provide name), ??
    1046     char key[10];
    1047     fprintf (stdout, "[c]ontinue? ");
    1048     if (!fgets(key, 8, stdin)) {
    1049         psWarning("Unable to read option");
    1050     }
    1051     return true;
    1052 }
    1053 
    1054 bool psphotVisualShowLinearFit (pmConfig *config, pmReadout *readout) {
     1045    psFree (psfMosaic);
     1046    psFree (psfLogFlux);
     1047
     1048    // pause and wait for user input:
     1049    // continue, save (provide name), ??
     1050    char key[10];
     1051    fprintf (stdout, "[c]ontinue? ");
     1052    if (!fgets(key, 8, stdin)) {
     1053        psWarning("Unable to read option");
     1054    }
     1055    return true;
     1056}
     1057
     1058bool psphotVisualShowFlags (pmConfig *config, const pmFPAview *view, psArray *sources) {
     1059
     1060    int NoverlayE, NOVERLAYE;
     1061    int NoverlayO, NOVERLAYO;
     1062    KiiOverlay *overlayE, *overlayO;
     1063 
     1064    psEllipseMoments emoments;
     1065    psEllipseAxes axes;
     1066
     1067    if (!isVisual) return true;
     1068
     1069    if (kapa == -1) {
     1070        fprintf (stderr, "kapa not opened, skipping\n");
     1071        return false;
     1072    }
     1073
     1074    // note: this uses the Ohana allocation tools:
     1075    NoverlayE = 0;
     1076    NOVERLAYE = 100;
     1077    ALLOCATE (overlayE, KiiOverlay, sources->n);
     1078
     1079    NoverlayO = 0;
     1080    NOVERLAYO = 100;
     1081    ALLOCATE (overlayO, KiiOverlay, sources->n);
     1082
     1083    for (int i = 0; i < sources->n; i++) {
     1084
     1085        float Xo, Yo, Rmaj, Rmin, cs, sn;
     1086
     1087        pmSource *source = sources->data[i];
     1088        if (source == NULL) continue;
     1089
     1090        pmMoments *moments = source->moments;
     1091        if (0) {
     1092            emoments.x2 = moments->Mxx;
     1093            emoments.y2 = moments->Myy;
     1094            emoments.xy = moments->Mxy;
     1095            Xo = moments->Mx;
     1096            Yo = moments->My;
     1097
     1098            axes = psEllipseMomentsToAxes (emoments, 20.0);
     1099            Rmaj = 2.0*axes.major;
     1100            Rmin = 2.0*axes.minor;
     1101            cs = cos(axes.theta);
     1102            sn = sin(axes.theta);
     1103        } else {
     1104            Rmaj = Rmin = 5.0;
     1105            cs = 1.0;
     1106            sn = 0.0;
     1107            Xo = source->peak->xf;
     1108            Yo = source->peak->yf;
     1109        }
     1110
     1111        unsigned short int flagMask = 0x01;
     1112        for (int j = 0; j < 8; j++) {
     1113            if (source->mode & flagMask) {
     1114                overlayE[NoverlayE].type = KII_OVERLAY_LINE;
     1115                overlayE[NoverlayE].x = Xo;
     1116                overlayE[NoverlayE].y = Yo;
     1117
     1118                float phi = j*M_PI/4.0;
     1119                overlayE[NoverlayE].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn;
     1120                overlayE[NoverlayE].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs;
     1121                overlayE[NoverlayE].angle = 0;
     1122                overlayE[NoverlayE].text = NULL;
     1123                NoverlayE ++;
     1124                CHECK_REALLOCATE (overlayE, KiiOverlay, NOVERLAYE, NoverlayE, 100);
     1125            }
     1126            flagMask <<= 1;
     1127
     1128            if (source->mode & flagMask) {
     1129                overlayO[NoverlayO].type = KII_OVERLAY_LINE;
     1130                overlayO[NoverlayO].x = Xo + 1;
     1131                overlayO[NoverlayO].y = Yo;
     1132
     1133                float phi = j*M_PI/4.0;
     1134                overlayO[NoverlayO].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn;
     1135                overlayO[NoverlayO].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs;
     1136                overlayO[NoverlayO].angle = 0;
     1137                overlayO[NoverlayO].text = NULL;
     1138                NoverlayO ++;
     1139                CHECK_REALLOCATE (overlayO, KiiOverlay, NOVERLAYO, NoverlayO, 100);
     1140            }
     1141            flagMask <<= 1;
     1142        }
     1143    }
     1144
     1145    KiiLoadOverlay (kapa, overlayE, NoverlayE, "red");
     1146    KiiLoadOverlay (kapa, overlayO, NoverlayO, "yellow");
     1147    FREE (overlayE);
     1148    FREE (overlayO);
     1149
     1150    // pause and wait for user input:
     1151    // continue, save (provide name), ??
     1152    char key[10];
     1153    fprintf (stdout, "even bits (0x0001, 0x0004, ... : red\n");
     1154    fprintf (stdout, "odd bits (0x0002, 0x0008, ... : yellow\n");
     1155    fprintf (stdout, "[c]ontinue? ");
     1156    if (!fgets(key, 8, stdin)) {
     1157        psWarning("Unable to read option");
     1158    }
     1159
     1160    return true;
     1161}
     1162
     1163bool psphotVisualShowSourceSize (pmConfig *config, const pmFPAview *view, psArray *sources) {
     1164
     1165    int Noverlay, NOVERLAY;
     1166    KiiOverlay *overlay;
     1167
     1168    if (!isVisual) return true;
     1169
     1170    if (kapa == -1) {
     1171        fprintf (stderr, "kapa not opened, skipping\n");
     1172        return false;
     1173    }
     1174
     1175    // note: this uses the Ohana allocation tools:
     1176    Noverlay = 0;
     1177    NOVERLAY = 100;
     1178    ALLOCATE (overlay, KiiOverlay, sources->n);
     1179
     1180    // mark CRs with red boxes
     1181    for (int i = 0; i < sources->n; i++) {
     1182
     1183        pmSource *source = sources->data[i];
     1184        if (source == NULL) continue;
     1185
     1186        if (!(source->mode & PM_SOURCE_MODE_CR_LIMIT)) continue;
     1187
     1188        overlay[Noverlay].type = KII_OVERLAY_BOX;
     1189        overlay[Noverlay].x = source->peak->xf;
     1190        overlay[Noverlay].y = source->peak->yf;
     1191
     1192        overlay[Noverlay].dx = 4;
     1193        overlay[Noverlay].dy = 4;
     1194        overlay[Noverlay].angle = 0;
     1195        overlay[Noverlay].text = NULL;
     1196        Noverlay ++;
     1197        CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100);
     1198    }
     1199    KiiLoadOverlay (kapa, overlay, Noverlay, "red");
     1200
     1201
     1202    Noverlay = 0;
     1203    for (int i = 0; i < sources->n; i++) {
     1204
     1205        pmSource *source = sources->data[i];
     1206        if (source == NULL) continue;
     1207
     1208        // mark EXTs with yellow circles
     1209        if (!(source->mode & PM_SOURCE_MODE_EXT_LIMIT)) continue;
     1210
     1211        overlay[Noverlay].type = KII_OVERLAY_CIRCLE;
     1212        overlay[Noverlay].x = source->peak->xf;
     1213        overlay[Noverlay].y = source->peak->yf;
     1214
     1215        overlay[Noverlay].dx = 10;
     1216        overlay[Noverlay].dy = 10;
     1217        overlay[Noverlay].angle = 0;
     1218        overlay[Noverlay].text = NULL;
     1219        Noverlay ++;
     1220        CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100);
     1221    }
     1222
     1223    KiiLoadOverlay (kapa, overlay, Noverlay, "yellow");
     1224    FREE (overlay);
     1225
     1226    // pause and wait for user input:
     1227    // continue, save (provide name), ??
     1228    char key[10];
     1229    fprintf (stdout, "CR: 4pix red BOX; EXT: 10pix blue circle\n");
     1230    fprintf (stdout, "[c]ontinue? ");
     1231    if (!fgets(key, 8, stdin)) {
     1232        psWarning("Unable to read option");
     1233    }
     1234
     1235    return true;
     1236}
     1237
     1238bool psphotVisualShowResidualImage (pmConfig *config, pmReadout *readout) {
    10551239
    10561240    if (!isVisual) return true;
    … …  
    10651249    } 
    10661250
    1067     psphotVisualScaleImage (kapa, readout->image, "lin_resid", 1);
     1251    psphotVisualScaleImage (kapa, readout->image, "resid", 1);
     1252
     1253    // pause and wait for user input:
     1254    // continue, save (provide name), ??
     1255    char key[10];
     1256    fprintf (stdout, "[c]ontinue? ");
     1257    if (!fgets(key, 8, stdin)) {
     1258        psWarning("Unable to read option");
     1259    }
     1260    return true;
     1261}
     1262
     1263bool psphotVisualPlotApResid (pmConfig *config, psArray *sources) {
     1264
     1265    bool status;
     1266    Graphdata graphdata;
     1267
     1268    if (!isVisual) return true;
     1269
     1270    if (kapa3 == -1) {
     1271        kapa3 = KapaOpenNamedSocket ("kapa", "psphot:plots");
     1272        if (kapa3 == -1) {
     1273            fprintf (stderr, "failure to open kapa; visual mode disabled\n");
     1274            isVisual = false;
     1275            return false;
     1276        }
     1277    } 
     1278
     1279    // select the current recipe
     1280    psMetadata *recipe = psMetadataLookupPtr (&status, config->recipes, PSPHOT_RECIPE);
     1281    if (!recipe) {
     1282        fprintf (stderr, "missing recipe, skipping moments plot\n");
     1283        return false;
     1284    }
     1285
     1286    KapaClearPlots (kapa3);
     1287    KapaInitGraph (&graphdata);
     1288
     1289    psVector *x = psVectorAllocEmpty (sources->n, PS_TYPE_F32);
     1290    psVector *y = psVectorAllocEmpty (sources->n, PS_TYPE_F32);
     1291
     1292    graphdata.xmin = +32.0;
     1293    graphdata.xmax = -32.0;
     1294    graphdata.ymin = +32.0;
     1295    graphdata.ymax = -32.0;
     1296
     1297    // construct the plot vectors
     1298    int n = 0;
     1299    for (int i = 0; i < sources->n; i++) {
     1300        pmSource *source = sources->data[i];
     1301        if (!source) continue;
     1302        if (source->type != PM_SOURCE_TYPE_STAR) continue;
     1303        if (!isfinite (source->apMag)) continue;
     1304        if (!isfinite (source->psfMag)) continue;
     1305
     1306        x->data.F32[n] = source->psfMag;
     1307        y->data.F32[n] = source->apMag - source->psfMag;
     1308        graphdata.xmin = PS_MIN(graphdata.xmin, x->data.F32[n]);
     1309        graphdata.xmax = PS_MAX(graphdata.xmax, x->data.F32[n]);
     1310        graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[n]);
     1311        graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[n]);
     1312
     1313        n++;
     1314    }
     1315    x->n = y->n = n;
     1316
     1317    float range;
     1318    range = graphdata.xmax - graphdata.xmin;
     1319    graphdata.xmax += 0.05*range;
     1320    graphdata.xmin -= 0.05*range;
     1321    range = graphdata.ymax - graphdata.ymin;
     1322    graphdata.ymax += 0.05*range;
     1323    graphdata.ymin -= 0.05*range;
     1324
     1325    // XXX set the plot range to match the image
     1326    KapaSetLimits (kapa3, &graphdata);
     1327
     1328    KapaSetFont (kapa3, "helvetica", 14);
     1329    KapaBox (kapa3, &graphdata);
     1330    KapaSendLabel (kapa3, "PSF Mag", KAPA_LABEL_XM);
     1331    KapaSendLabel (kapa3, "Ap Mag - PSF Mag", KAPA_LABEL_YM);
     1332
     1333    graphdata.color = KapaColorByName ("black");
     1334    graphdata.ptype = 2;
     1335    graphdata.size = 0.5;
     1336    graphdata.style = 2;
     1337    KapaPrepPlot (kapa3, n, &graphdata);
     1338    KapaPlotVector (kapa3, n, x->data.F32, "x");
     1339    KapaPlotVector (kapa3, n, y->data.F32, "y");
     1340
     1341    psFree (x);
     1342    psFree (y);
    10681343
    10691344    // pause and wait for user input:
    … …  
    10801355
    10811356bool psphotSetVisual (bool mode){}
    1082 bool psphotVisualShowImage (pmConfig *config, pmReadout *readout){}
    1083 bool psphotVisualShowBackground (pmConfig *config, const pmFPAview *view, pmReadout *readout){}
    1084 bool psphotVisualShowSignificance (psImage *image){}
    1085 bool psphotVisualShowPeaks (pmConfig *config, const pmFPAview *view, pmDetections *detections){}
    1086 bool psphotVisualShowFootprints (pmConfig *config, const pmFPAview *view, pmDetections *detections){}
    1087 bool psphotVisualShowMoments (pmConfig *config, const pmFPAview *view, psArray *sources){}
    1088 bool psphotVisualShowRoughClass (pmConfig *config, const pmFPAview *view, psArray *sources){}
    1089 bool psphotVisualShowPSF (pmConfig *config, const pmFPAview *view, pmPSF *psf, psArray *sources){}
    1090 bool psphotVisualShowLinearFit (pmConfig *config, pmReadout *readout){}
     1357bool psphotVisualShowImage (pmConfig *config, pmReadout *readout) { return true; }
     1358bool psphotVisualShowBackground (pmConfig *config, const pmFPAview *view, pmReadout *readout) { return true; }
     1359bool psphotVisualShowSignificance (psImage *image) { return true; }
     1360bool psphotVisualShowPeaks (pmConfig *config, const pmFPAview *view, pmDetections *detections) { return true; }
     1361bool psphotVisualShowFootprints (pmConfig *config, const pmFPAview *view, pmDetections *detections) { return true; }
     1362bool psphotVisualShowMoments (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
     1363bool psphotVisualPlotMoments (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
     1364bool psphotVisualShowRoughClass (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
     1365bool psphotVisualShowPSFStars (pmConfig *config, const pmFPAview *view, pmPSF *psf, psArray *sources) { return true; }
     1366bool psphotVisualShowSatStars (pmConfig *config, const pmFPAview *view, pmPSF *psf, psArray *sources) { return true; }
     1367bool psphotVisualShowPSFModel (pmConfig *config, pmReadout *readout, pmPSF *psf) { return true; }
     1368bool psphotVisualShowFlags (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
     1369bool psphotVisualSourceSize (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
     1370bool psphotVisualShowResidualImage (pmConfig *config, pmReadout *readout) { return true; }
     1371bool psphotVisualPlotApResid (pmConfig *config, const pmFPAview *view, psArray *sources) { return true; }
    10911372
    10921373# endif
Note: See TracChangeset for help on using the changeset viewer.