IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18848


Ignore:
Timestamp:
Aug 1, 2008, 8:40:18 AM (18 years ago)
Author:
Paul Price
Message:

Need to check return value of fgets to avoid compiler warnings on some
systems.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psastro/src/psastroDemoPlot.c

    r17322 r18848  
    4646    int n = 0;
    4747    for (int i = 0; i < rawstars->n; i++) {
    48         pmAstromObj *raw = rawstars->data[i];
    49         if (!isfinite(raw->Mag)) continue;
    50         if (raw->Mag < iMagMin) continue;
    51         if (raw->Mag > iMagMax) continue;
    52 
    53         xVec->data.F32[n] = raw->chip->x;
    54         yVec->data.F32[n] = raw->chip->y;
    55         zVec->data.F32[n] = raw->Mag;
    56         n++;
     48        pmAstromObj *raw = rawstars->data[i];
     49        if (!isfinite(raw->Mag)) continue;
     50        if (raw->Mag < iMagMin) continue;
     51        if (raw->Mag > iMagMax) continue;
     52
     53        xVec->data.F32[n] = raw->chip->x;
     54        yVec->data.F32[n] = raw->chip->y;
     55        zVec->data.F32[n] = raw->Mag;
     56        n++;
    5757    }
    5858    xVec->n = yVec->n = zVec->n = n;
    … …  
    6868    n = 0;
    6969    for (int i = 0; i < rawstars->n; i++) {
    70         pmAstromObj *raw = rawstars->data[i];
    71         if (!isfinite(raw->Mag)) continue;
    72         if (raw->Mag < iMagMin) continue;
    73         if (raw->Mag > iMagMax) continue;
    74 
    75         xVec->data.F32[n] = raw->FP->x;
    76         yVec->data.F32[n] = raw->FP->y;
    77         zVec->data.F32[n] = raw->Mag;
    78         n++;
     70        pmAstromObj *raw = rawstars->data[i];
     71        if (!isfinite(raw->Mag)) continue;
     72        if (raw->Mag < iMagMin) continue;
     73        if (raw->Mag > iMagMax) continue;
     74
     75        xVec->data.F32[n] = raw->FP->x;
     76        yVec->data.F32[n] = raw->FP->y;
     77        zVec->data.F32[n] = raw->Mag;
     78        n++;
    7979    }
    8080    xVec->n = yVec->n = zVec->n = n;
    … …  
    9090    n = 0;
    9191    for (int i = 0; i < rawstars->n; i++) {
    92         pmAstromObj *raw = rawstars->data[i];
    93         if (!isfinite(raw->Mag)) continue;
    94         if (raw->Mag < iMagMin) continue;
    95         if (raw->Mag > iMagMax) continue;
    96 
    97         xVec->data.F32[n] = raw->TP->x;
    98         yVec->data.F32[n] = raw->TP->y;
    99         zVec->data.F32[n] = raw->Mag;
    100         n++;
     92        pmAstromObj *raw = rawstars->data[i];
     93        if (!isfinite(raw->Mag)) continue;
     94        if (raw->Mag < iMagMin) continue;
     95        if (raw->Mag > iMagMax) continue;
     96
     97        xVec->data.F32[n] = raw->TP->x;
     98        yVec->data.F32[n] = raw->TP->y;
     99        zVec->data.F32[n] = raw->Mag;
     100        n++;
    101101    }
    102102    xVec->n = yVec->n = zVec->n = n;
    … …  
    112112    n = 0;
    113113    for (int i = 0; i < rawstars->n; i++) {
    114         pmAstromObj *raw = rawstars->data[i];
    115         if (!isfinite(raw->Mag)) continue;
    116         if (raw->Mag < iMagMin) continue;
    117         if (raw->Mag > iMagMax) continue;
    118 
    119         xVec->data.F32[n] = DEG_RAD*raw->sky->r;
    120         yVec->data.F32[n] = DEG_RAD*raw->sky->d;
    121         zVec->data.F32[n] = raw->Mag;
    122         n++;
    123     }
    124     xVec->n = yVec->n = zVec->n = n;
    125     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    126 
    127     // pause and wait for user input:
     114        pmAstromObj *raw = rawstars->data[i];
     115        if (!isfinite(raw->Mag)) continue;
     116        if (raw->Mag < iMagMin) continue;
     117        if (raw->Mag > iMagMax) continue;
     118
     119        xVec->data.F32[n] = DEG_RAD*raw->sky->r;
     120        yVec->data.F32[n] = DEG_RAD*raw->sky->d;
     121        zVec->data.F32[n] = raw->Mag;
     122        n++;
     123    }
     124    xVec->n = yVec->n = zVec->n = n;
     125    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     126
     127    // pause and wait for user input:
     128    // continue, save (provide name), ??
     129    char key[10], name[80];
     130    fprintf (stdout, "(s)ave plot or [c]ontinue? ");
     131    if (!fgets(key, 8, stdin)) {
     132        psWarning("Unable to read option");
     133    } else if (key[0] == 's') {
     134        fprintf (stdout, "enter plot name [rawstars.png]: ");
     135        fscanf (stdin, "%s", name);
     136        if (!strcmp (name, "")) strcpy (name, "rawstars.png");
     137        KapaPNG (kapa, name);
     138    }
     139
     140    psFree (xVec);
     141    psFree (yVec);
     142    psFree (zVec);
     143    return true;
     144}
     145
     146bool psastroPlotRefstars (psArray *refstars, psMetadata *recipe)
     147{
     148    Graphdata graphdata;
     149
     150    int kapa = pmKapaOpen (true);
     151    if (kapa == -1) {
     152        psError(PS_ERR_UNKNOWN, true, "failure to open kapa");
     153        return false;
     154    }
     155
     156    bool status = false;
     157    float rMagMin = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MIN");
     158    float rMagMax = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MAX");
     159
     160    KapaResize (kapa, 1000, 1000);
     161    KapaInitGraph (&graphdata);
     162    KapaClearSections (kapa);
     163
     164    graphdata.color = KapaColorByName ("black");
     165    graphdata.ptype = 7;
     166    graphdata.size = 0.5;
     167    graphdata.style = 2;
     168
     169    psVector *xVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     170    psVector *yVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     171    psVector *zVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     172
     173    int n = 0;
     174    for (int i = 0; i < refstars->n; i++) {
     175        pmAstromObj *ref = refstars->data[i];
     176        if (!isfinite(ref->Mag)) continue;
     177        if (ref->Mag > rMagMax) continue;
     178        if (ref->Mag < rMagMin) continue;
     179
     180        xVec->data.F32[n] = DEG_RAD*ref->sky->r;
     181        yVec->data.F32[n] = DEG_RAD*ref->sky->d;
     182        zVec->data.F32[n] = ref->Mag;
     183        n++;
     184    }
     185    xVec->n = yVec->n = zVec->n = n;
     186    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     187
     188    // pause and wait for user input:
    128189    // continue, save (provide name), ??
    129190    char key[10], name[80];
    … …  
    131192    fgets (key, 8, stdin);
    132193    if (key[0] == 's') {
    133         fprintf (stdout, "enter plot name [rawstars.png]: ");
    134         fscanf (stdin, "%s", name);
    135         if (!strcmp (name, "")) strcpy (name, "rawstars.png");
    136         KapaPNG (kapa, name);
     194        fprintf (stdout, "enter plot name [refstars.png]: ");
     195        fscanf (stdin, "%s", name);
     196        if (!strcmp (name, "")) strcpy (name, "refstars.png");
     197        KapaPNG (kapa, name);
    137198    }
    138199
    … …  
    143204}
    144205
    145 bool psastroPlotRefstars (psArray *refstars, psMetadata *recipe)
    146 {
     206bool psastroPlotOneChipFit (psArray *rawstars, psArray *refstars, psArray *match, psMetadata *recipe) {
     207
    147208    Graphdata graphdata;
     209    KapaSection section;
    148210
    149211    int kapa = pmKapaOpen (true);
    … …  
    154216
    155217    bool status = false;
     218    float iMagMin = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.INST.MAG.MIN");
     219    float iMagMax = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.INST.MAG.MAX");
    156220    float rMagMin = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MIN");
    157221    float rMagMax = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MAX");
    … …  
    159223    KapaResize (kapa, 1000, 1000);
    160224    KapaInitGraph (&graphdata);
    161     KapaClearSections (kapa);
     225    KapaClearPlots (kapa);
    162226
    163227    graphdata.color = KapaColorByName ("black");
    … …  
    166230    graphdata.style = 2;
    167231
    168     psVector *xVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
    169     psVector *yVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
    170     psVector *zVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     232    section.dx = 0.5;
     233    section.dy = 0.5;
     234
     235    psVector *xVec = psVectorAlloc (match->n, PS_TYPE_F32);
     236    psVector *yVec = psVectorAlloc (match->n, PS_TYPE_F32);
     237    psVector *zVec = psVectorAlloc (match->n, PS_TYPE_F32);
     238
     239    // X vs dX
     240    section.x = 0.0;
     241    section.y = 0.5;
     242    section.name = NULL;
     243    psStringAppend (&section.name, "a0");
     244    KapaSetSection (kapa, &section);
     245    psFree (section.name);
    171246
    172247    int n = 0;
     248    for (int i = 0; i < match->n; i++) {
     249        pmAstromMatch *pair = match->data[i];
     250        pmAstromObj *raw = rawstars->data[pair->raw];
     251        pmAstromObj *ref = refstars->data[pair->ref];
     252
     253        if (raw->Mag < iMagMin) continue;
     254        if (raw->Mag > iMagMax) continue;
     255        if (ref->Mag < rMagMin) continue;
     256        if (ref->Mag > rMagMax) continue;
     257
     258        xVec->data.F32[n] = raw->chip->x;
     259        yVec->data.F32[n] = raw->chip->x - ref->chip->x;
     260        zVec->data.F32[n] = raw->Mag;
     261        n++;
     262    }
     263    xVec->n = yVec->n = zVec->n = n;
     264    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     265
     266    // X vs dY
     267    section.x = 0.5;
     268    section.y = 0.5;
     269    section.name = NULL;
     270    psStringAppend (&section.name, "a1");
     271    KapaSetSection (kapa, &section);
     272    psFree (section.name);
     273
     274    n = 0;
     275    for (int i = 0; i < match->n; i++) {
     276        pmAstromMatch *pair = match->data[i];
     277        pmAstromObj *raw = rawstars->data[pair->raw];
     278        pmAstromObj *ref = refstars->data[pair->ref];
     279
     280        if (!isfinite(raw->Mag)) continue;
     281        if (raw->Mag < iMagMin) continue;
     282        if (raw->Mag > iMagMax) continue;
     283        if (ref->Mag < rMagMin) continue;
     284        if (ref->Mag > rMagMax) continue;
     285
     286        xVec->data.F32[n] = raw->chip->x;
     287        yVec->data.F32[n] = raw->chip->y - ref->chip->y;
     288        zVec->data.F32[n] = raw->Mag;
     289        n++;
     290    }
     291    xVec->n = yVec->n = zVec->n = n;
     292    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     293
     294    // Y vs dX
     295    section.x = 0.0;
     296    section.y = 0.0;
     297    section.name = NULL;
     298    psStringAppend (&section.name, "a2");
     299    KapaSetSection (kapa, &section);
     300    psFree (section.name);
     301
     302    n = 0;
     303    for (int i = 0; i < match->n; i++) {
     304        pmAstromMatch *pair = match->data[i];
     305        pmAstromObj *raw = rawstars->data[pair->raw];
     306        pmAstromObj *ref = refstars->data[pair->ref];
     307
     308        if (!isfinite(raw->Mag)) continue;
     309        if (raw->Mag < iMagMin) continue;
     310        if (raw->Mag > iMagMax) continue;
     311        if (ref->Mag < rMagMin) continue;
     312        if (ref->Mag > rMagMax) continue;
     313
     314        xVec->data.F32[n] = raw->chip->y;
     315        yVec->data.F32[n] = raw->chip->x - ref->chip->x;
     316        zVec->data.F32[n] = raw->Mag;
     317        n++;
     318    }
     319    xVec->n = yVec->n = zVec->n = n;
     320    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     321
     322    // Y vs dY
     323    section.x = 0.5;
     324    section.y = 0.0;
     325    section.name = NULL;
     326    psStringAppend (&section.name, "a3");
     327    KapaSetSection (kapa, &section);
     328    psFree (section.name);
     329
     330    n = 0;
     331    for (int i = 0; i < match->n; i++) {
     332        pmAstromMatch *pair = match->data[i];
     333        pmAstromObj *raw = rawstars->data[pair->raw];
     334        pmAstromObj *ref = refstars->data[pair->ref];
     335
     336        if (!isfinite(raw->Mag)) continue;
     337        if (raw->Mag < iMagMin) continue;
     338        if (raw->Mag > iMagMax) continue;
     339        if (ref->Mag < rMagMin) continue;
     340        if (ref->Mag > rMagMax) continue;
     341
     342        xVec->data.F32[n] = raw->chip->y;
     343        yVec->data.F32[n] = raw->chip->y - ref->chip->y;
     344        zVec->data.F32[n] = raw->Mag;
     345        n++;
     346    }
     347    xVec->n = yVec->n = zVec->n = n;
     348    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
     349
     350    // *** X vs Y plot (different window)
     351    int kapa2 = KapaOpenNamedSocket ("kapa", "XvsY");
     352    if (kapa2 == -1) {
     353        psError(PS_ERR_UNKNOWN, true, "failure to open kapa");
     354        return false;
     355    }
     356
     357    KapaResize (kapa2, 1000, 1000);
     358    KapaInitGraph (&graphdata);
     359    KapaClearPlots (kapa2);
     360
     361    graphdata.color = KapaColorByName ("black");
     362    graphdata.ptype = 2;
     363    graphdata.style = 2;
     364
     365    psFree (xVec);
     366    psFree (yVec);
     367    psFree (zVec);
     368
     369    xVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
     370    yVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
     371    zVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
     372
     373    // X vs Y by mag (raw)
     374    n = 0;
     375    for (int i = 0; i < rawstars->n; i++) {
     376        pmAstromObj *raw = rawstars->data[i];
     377        if (!isfinite(raw->Mag)) continue;
     378        if (raw->Mag < iMagMin) continue;
     379        if (raw->Mag > iMagMax) continue;
     380
     381        xVec->data.F32[n] = raw->chip->x;
     382        yVec->data.F32[n] = raw->chip->y;
     383        zVec->data.F32[n] = raw->Mag;
     384        n++;
     385    }
     386    xVec->n = yVec->n = zVec->n = n;
     387    pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa2, &graphdata, xVec, yVec, zVec, false);
     388
     389    graphdata.color = KapaColorByName ("red");
     390    graphdata.ptype = 7;
     391    graphdata.style = 2;
     392
     393    psFree (xVec);
     394    psFree (yVec);
     395    psFree (zVec);
     396
     397    xVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     398    yVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     399    zVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
     400
     401    // X vs Y by mag (raw)
     402    n = 0;
    173403    for (int i = 0; i < refstars->n; i++) {
    174         pmAstromObj *ref = refstars->data[i];
    175         if (!isfinite(ref->Mag)) continue;
    176         if (ref->Mag > rMagMax) continue;
    177         if (ref->Mag < rMagMin) continue;
    178 
    179         xVec->data.F32[n] = DEG_RAD*ref->sky->r;
    180         yVec->data.F32[n] = DEG_RAD*ref->sky->d;
    181         zVec->data.F32[n] = ref->Mag;
    182         n++;
    183     }
    184     xVec->n = yVec->n = zVec->n = n;
    185     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    186 
    187     // pause and wait for user input: 
     404        pmAstromObj *ref = refstars->data[i];
     405        if (!isfinite(ref->Mag)) continue;
     406        if (ref->Mag < rMagMin) continue;
     407        if (ref->Mag > rMagMax) continue;
     408
     409        xVec->data.F32[n] = ref->chip->x;
     410        yVec->data.F32[n] = ref->chip->y;
     411        zVec->data.F32[n] = ref->Mag;
     412        n++;
     413    }
     414    xVec->n = yVec->n = zVec->n = n;
     415    pmKapaPlotVectorTriple_AutoLimitsZscale_OpenGraph (kapa2, &graphdata, xVec, yVec, zVec, false);
     416
     417    // pause and wait for user input:
    188418    // continue, save (provide name), ??
    189419    char key[10], name[80];
    … …  
    191421    fgets (key, 8, stdin);
    192422    if (key[0] == 's') {
    193         fprintf (stdout, "enter plot name [refstars.png]: ");
    194         fscanf (stdin, "%s", name);
    195         if (!strcmp (name, "")) strcpy (name, "refstars.png");
    196         KapaPNG (kapa, name);
    197     }
    198 
    199     psFree (xVec);
    200     psFree (yVec);
    201     psFree (zVec);
    202     return true;
    203 }
    204 
    205 bool psastroPlotOneChipFit (psArray *rawstars, psArray *refstars, psArray *match, psMetadata *recipe) {
    206 
    207     Graphdata graphdata;
    208     KapaSection section;
    209 
    210     int kapa = pmKapaOpen (true);
    211     if (kapa == -1) {
    212         psError(PS_ERR_UNKNOWN, true, "failure to open kapa");
    213         return false;
    214     }
    215 
    216     bool status = false;
    217     float iMagMin = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.INST.MAG.MIN");
    218     float iMagMax = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.INST.MAG.MAX");
    219     float rMagMin = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MIN");
    220     float rMagMax = psMetadataLookupF32 (&status, recipe, "PSASTRO.PLOT.REF.MAG.MAX");
    221 
    222     KapaResize (kapa, 1000, 1000);
    223     KapaInitGraph (&graphdata);
    224     KapaClearPlots (kapa);
    225 
    226     graphdata.color = KapaColorByName ("black");
    227     graphdata.ptype = 7;
    228     graphdata.size = 0.5;
    229     graphdata.style = 2;
    230 
    231     section.dx = 0.5;
    232     section.dy = 0.5;
    233 
    234     psVector *xVec = psVectorAlloc (match->n, PS_TYPE_F32);
    235     psVector *yVec = psVectorAlloc (match->n, PS_TYPE_F32);
    236     psVector *zVec = psVectorAlloc (match->n, PS_TYPE_F32);
    237 
    238     // X vs dX
    239     section.x = 0.0;
    240     section.y = 0.5;
    241     section.name = NULL;
    242     psStringAppend (&section.name, "a0");
    243     KapaSetSection (kapa, &section);
    244     psFree (section.name);
    245 
    246     int n = 0;
    247     for (int i = 0; i < match->n; i++) {
    248         pmAstromMatch *pair = match->data[i];
    249         pmAstromObj *raw = rawstars->data[pair->raw];
    250         pmAstromObj *ref = refstars->data[pair->ref];
    251        
    252         if (raw->Mag < iMagMin) continue;
    253         if (raw->Mag > iMagMax) continue;
    254         if (ref->Mag < rMagMin) continue;
    255         if (ref->Mag > rMagMax) continue;
    256 
    257         xVec->data.F32[n] = raw->chip->x;
    258         yVec->data.F32[n] = raw->chip->x - ref->chip->x;
    259         zVec->data.F32[n] = raw->Mag;
    260         n++;
    261     }   
    262     xVec->n = yVec->n = zVec->n = n;
    263     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    264 
    265     // X vs dY
    266     section.x = 0.5;
    267     section.y = 0.5;
    268     section.name = NULL;
    269     psStringAppend (&section.name, "a1");
    270     KapaSetSection (kapa, &section);
    271     psFree (section.name);
    272 
    273     n = 0;
    274     for (int i = 0; i < match->n; i++) {
    275         pmAstromMatch *pair = match->data[i];
    276         pmAstromObj *raw = rawstars->data[pair->raw];
    277         pmAstromObj *ref = refstars->data[pair->ref];
    278        
    279         if (!isfinite(raw->Mag)) continue;
    280         if (raw->Mag < iMagMin) continue;
    281         if (raw->Mag > iMagMax) continue;
    282         if (ref->Mag < rMagMin) continue;
    283         if (ref->Mag > rMagMax) continue;
    284 
    285         xVec->data.F32[n] = raw->chip->x;
    286         yVec->data.F32[n] = raw->chip->y - ref->chip->y;
    287         zVec->data.F32[n] = raw->Mag;
    288         n++;
    289     }   
    290     xVec->n = yVec->n = zVec->n = n;
    291     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    292 
    293     // Y vs dX
    294     section.x = 0.0;
    295     section.y = 0.0;
    296     section.name = NULL;
    297     psStringAppend (&section.name, "a2");
    298     KapaSetSection (kapa, &section);
    299     psFree (section.name);
    300 
    301     n = 0;
    302     for (int i = 0; i < match->n; i++) {
    303         pmAstromMatch *pair = match->data[i];
    304         pmAstromObj *raw = rawstars->data[pair->raw];
    305         pmAstromObj *ref = refstars->data[pair->ref];
    306        
    307         if (!isfinite(raw->Mag)) continue;
    308         if (raw->Mag < iMagMin) continue;
    309         if (raw->Mag > iMagMax) continue;
    310         if (ref->Mag < rMagMin) continue;
    311         if (ref->Mag > rMagMax) continue;
    312 
    313         xVec->data.F32[n] = raw->chip->y;
    314         yVec->data.F32[n] = raw->chip->x - ref->chip->x;
    315         zVec->data.F32[n] = raw->Mag;
    316         n++;
    317     }   
    318     xVec->n = yVec->n = zVec->n = n;
    319     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    320 
    321     // Y vs dY
    322     section.x = 0.5;
    323     section.y = 0.0;
    324     section.name = NULL;
    325     psStringAppend (&section.name, "a3");
    326     KapaSetSection (kapa, &section);
    327     psFree (section.name);
    328 
    329     n = 0;
    330     for (int i = 0; i < match->n; i++) {
    331         pmAstromMatch *pair = match->data[i];
    332         pmAstromObj *raw = rawstars->data[pair->raw];
    333         pmAstromObj *ref = refstars->data[pair->ref];
    334        
    335         if (!isfinite(raw->Mag)) continue;
    336         if (raw->Mag < iMagMin) continue;
    337         if (raw->Mag > iMagMax) continue;
    338         if (ref->Mag < rMagMin) continue;
    339         if (ref->Mag > rMagMax) continue;
    340 
    341         xVec->data.F32[n] = raw->chip->y;
    342         yVec->data.F32[n] = raw->chip->y - ref->chip->y;
    343         zVec->data.F32[n] = raw->Mag;
    344         n++;
    345     }   
    346     xVec->n = yVec->n = zVec->n = n;
    347     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa, &graphdata, xVec, yVec, zVec, false);
    348 
    349     // *** X vs Y plot (different window)
    350     int kapa2 = KapaOpenNamedSocket ("kapa", "XvsY");
    351     if (kapa2 == -1) {
    352         psError(PS_ERR_UNKNOWN, true, "failure to open kapa");
    353         return false;
    354     }
    355 
    356     KapaResize (kapa2, 1000, 1000);
    357     KapaInitGraph (&graphdata);
    358     KapaClearPlots (kapa2);
    359 
    360     graphdata.color = KapaColorByName ("black");
    361     graphdata.ptype = 2;
    362     graphdata.style = 2;
    363 
    364     psFree (xVec);
    365     psFree (yVec);
    366     psFree (zVec);
    367 
    368     xVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
    369     yVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
    370     zVec = psVectorAlloc (rawstars->n, PS_TYPE_F32);
    371 
    372     // X vs Y by mag (raw)
    373     n = 0;
    374     for (int i = 0; i < rawstars->n; i++) {
    375         pmAstromObj *raw = rawstars->data[i];
    376         if (!isfinite(raw->Mag)) continue;
    377         if (raw->Mag < iMagMin) continue;
    378         if (raw->Mag > iMagMax) continue;
    379 
    380         xVec->data.F32[n] = raw->chip->x;
    381         yVec->data.F32[n] = raw->chip->y;
    382         zVec->data.F32[n] = raw->Mag;
    383         n++;
    384     }   
    385     xVec->n = yVec->n = zVec->n = n;
    386     pmKapaPlotVectorTriple_AutoLimits_OpenGraph (kapa2, &graphdata, xVec, yVec, zVec, false);
    387 
    388     graphdata.color = KapaColorByName ("red");
    389     graphdata.ptype = 7;
    390     graphdata.style = 2;
    391 
    392     psFree (xVec);
    393     psFree (yVec);
    394     psFree (zVec);
    395 
    396     xVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
    397     yVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
    398     zVec = psVectorAlloc (refstars->n, PS_TYPE_F32);
    399 
    400     // X vs Y by mag (raw)
    401     n = 0;
    402     for (int i = 0; i < refstars->n; i++) {
    403         pmAstromObj *ref = refstars->data[i];
    404         if (!isfinite(ref->Mag)) continue;
    405         if (ref->Mag < rMagMin) continue;
    406         if (ref->Mag > rMagMax) continue;
    407 
    408         xVec->data.F32[n] = ref->chip->x;
    409         yVec->data.F32[n] = ref->chip->y;
    410         zVec->data.F32[n] = ref->Mag;
    411         n++;
    412     }   
    413     xVec->n = yVec->n = zVec->n = n;
    414     pmKapaPlotVectorTriple_AutoLimitsZscale_OpenGraph (kapa2, &graphdata, xVec, yVec, zVec, false);
    415 
    416     // pause and wait for user input:
    417     // continue, save (provide name), ??
    418     char key[10], name[80];
    419     fprintf (stdout, "(s)ave plot or [c]ontinue? ");
    420     fgets (key, 8, stdin);
    421     if (key[0] == 's') {
    422         fprintf (stdout, "enter plot name [chipfit.png]: ");
    423         fscanf (stdin, "%s", name);
    424         if (!strcmp (name, "")) strcpy (name, "chipfit.png");
    425         KapaPNG (kapa, name);
     423        fprintf (stdout, "enter plot name [chipfit.png]: ");
     424        fscanf (stdin, "%s", name);
     425        if (!strcmp (name, "")) strcpy (name, "chipfit.png");
     426        KapaPNG (kapa, name);
    426427    }
    427428
    … …  
    485486}
    486487
    487 bool psastroPlotOneChipFit (psArray *rawstars, psArray *refstars, psArray *match, 
     488bool psastroPlotOneChipFit (psArray *rawstars, psArray *refstars, psArray *match,
    488489    psMetadata *recipe)
    489490{
Note: See TracChangeset for help on using the changeset viewer.