IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 20700


Ignore:
Timestamp:
Nov 11, 2008, 3:24:08 PM (17 years ago)
Author:
Paul Price
Message:

Adding diffskyfile, warpskyfile, chipprocessedimfile, rawimfile modes to magictool.

Location:
trunk/ippTools
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r20397 r20700  
    115115     magictool_toskyfilemask.sql \
    116116     magictool_totree.sql \
     117     magictool_diffskyfile.sql \
     118     magictool_warpskyfile.sql \
     119     magictool_chipprocessedimfile.sql \
     120     magictool_rawimfile.sql \
    117121     pstamptool_addjob_otherjob.sql \
    118122     pstamptool_addjob_stampjob.sql \

  • trunk/ippTools/src/magictool.c

    r20692 r20700  
    4747static bool revertmaskMode(pxConfig *config);
    4848static bool maskMode(pxConfig *config);
     49static bool diffskyfileMode(pxConfig *config);
     50static bool warpskyfileMode(pxConfig *config);
     51static bool chipprocessedimfileMode(pxConfig *config);
     52static bool rawimfileMode(pxConfig *config);
     53
    4954
    5055static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    6974
    7075    switch (config->mode) {
    71         MODECASE(MAGICTOOL_MODE_DEFINEBYQUERY,  definebyqueryMode);
    72         MODECASE(MAGICTOOL_MODE_DEFINERUN,      definerunMode);
    73         MODECASE(MAGICTOOL_MODE_UPDATERUN,      updaterunMode);
    74         MODECASE(MAGICTOOL_MODE_ADDINPUTSKYFILE,addinputskyfileMode);
    75         MODECASE(MAGICTOOL_MODE_INPUTSKYFILE,   inputskyfileMode);
    76         MODECASE(MAGICTOOL_MODE_TOTREE,         totreeMode);
    77         MODECASE(MAGICTOOL_MODE_INPUTTREE,      inputtreeMode);
    78         MODECASE(MAGICTOOL_MODE_REVERTTREE,     reverttreeMode);
    79         MODECASE(MAGICTOOL_MODE_TOPROCESS,      toprocessMode);
    80         MODECASE(MAGICTOOL_MODE_ADDRESULT,      addresultMode);
    81         MODECASE(MAGICTOOL_MODE_REVERTNODE,     revertnodeMode);
    82         MODECASE(MAGICTOOL_MODE_INPUTS,         inputsMode);
    83         MODECASE(MAGICTOOL_MODE_TOMASK,         tomaskMode);
    84         MODECASE(MAGICTOOL_MODE_ADDMASK,        addmaskMode);
    85         MODECASE(MAGICTOOL_MODE_REVERTMASK,     revertmaskMode);
    86         MODECASE(MAGICTOOL_MODE_MASK,           maskMode);
     76        MODECASE(MAGICTOOL_MODE_DEFINEBYQUERY,       definebyqueryMode);
     77        MODECASE(MAGICTOOL_MODE_DEFINERUN,           definerunMode);
     78        MODECASE(MAGICTOOL_MODE_UPDATERUN,           updaterunMode);
     79        MODECASE(MAGICTOOL_MODE_ADDINPUTSKYFILE,     addinputskyfileMode);
     80        MODECASE(MAGICTOOL_MODE_INPUTSKYFILE,        inputskyfileMode);
     81        MODECASE(MAGICTOOL_MODE_TOTREE,              totreeMode);
     82        MODECASE(MAGICTOOL_MODE_INPUTTREE,           inputtreeMode);
     83        MODECASE(MAGICTOOL_MODE_REVERTTREE,          reverttreeMode);
     84        MODECASE(MAGICTOOL_MODE_TOPROCESS,           toprocessMode);
     85        MODECASE(MAGICTOOL_MODE_ADDRESULT,           addresultMode);
     86        MODECASE(MAGICTOOL_MODE_REVERTNODE,          revertnodeMode);
     87        MODECASE(MAGICTOOL_MODE_INPUTS,              inputsMode);
     88        MODECASE(MAGICTOOL_MODE_TOMASK,              tomaskMode);
     89        MODECASE(MAGICTOOL_MODE_ADDMASK,             addmaskMode);
     90        MODECASE(MAGICTOOL_MODE_REVERTMASK,          revertmaskMode);
     91        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
     92        MODECASE(MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileMode);
     93        MODECASE(MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileMode);
     94        MODECASE(MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileMode);
     95        MODECASE(MAGICTOOL_MODE_RAWIMFILE,           rawimfileMode);
    8796        default:
    8897            psAbort("invalid option (this should not happen)");
    … …  
    12321241
    12331242
     1243static bool diffskyfileMode(pxConfig *config)
     1244{
     1245    PS_ASSERT_PTR_NON_NULL(config, false);
     1246
     1247    psMetadata *where = psMetadataAlloc();
     1248    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1249    PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
     1250
     1251    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1252
     1253    psString query = pxDataGet("magictool_diffskyfile.sql");
     1254    if (!query) {
     1255        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1256        return false;
     1257    }
     1258
     1259    if (psListLength(where->list)) {
     1260        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1261        psStringAppend(&query, " AND %s", whereClause);
     1262        psFree(whereClause);
     1263    }
     1264    psFree(where);
     1265
     1266    if (!p_psDBRunQuery(config->dbh, query)) {
     1267        psError(PS_ERR_UNKNOWN, false, "database error");
     1268        psFree(query);
     1269        return false;
     1270    }
     1271    psFree(query);
     1272
     1273    psArray *output = p_psDBFetchResult(config->dbh);
     1274    if (!output) {
     1275        psErrorCode err = psErrorCodeLast();
     1276        switch (err) {
     1277            case PS_ERR_DB_CLIENT:
     1278                psError(PXTOOLS_ERR_SYS, false, "database error");
     1279            case PS_ERR_DB_SERVER:
     1280                psError(PXTOOLS_ERR_PROG, false, "database error");
     1281            default:
     1282                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1283        }
     1284
     1285        return false;
     1286    }
     1287    if (!psArrayLength(output)) {
     1288        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1289        psFree(output);
     1290        return true;
     1291    }
     1292
     1293    if (psArrayLength(output)) {
     1294        // negative simple so the default is true
     1295        if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
     1296            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1297            psFree(output);
     1298            return false;
     1299        }
     1300    }
     1301
     1302    psFree(output);
     1303
     1304    return true;
     1305}
     1306
     1307
     1308static bool warpskyfileMode(pxConfig *config)
     1309{
     1310    PS_ASSERT_PTR_NON_NULL(config, false);
     1311
     1312    psMetadata *where = psMetadataAlloc();
     1313    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1314
     1315    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1316
     1317    psString query = pxDataGet("magictool_warpskyfile.sql");
     1318    if (!query) {
     1319        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1320        return false;
     1321    }
     1322
     1323    if (psListLength(where->list)) {
     1324        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1325        psStringAppend(&query, " AND %s", whereClause);
     1326        psFree(whereClause);
     1327    }
     1328    psFree(where);
     1329
     1330    if (!p_psDBRunQuery(config->dbh, query)) {
     1331        psError(PS_ERR_UNKNOWN, false, "database error");
     1332        psFree(query);
     1333        return false;
     1334    }
     1335    psFree(query);
     1336
     1337    psArray *output = p_psDBFetchResult(config->dbh);
     1338    if (!output) {
     1339        psErrorCode err = psErrorCodeLast();
     1340        switch (err) {
     1341            case PS_ERR_DB_CLIENT:
     1342                psError(PXTOOLS_ERR_SYS, false, "database error");
     1343            case PS_ERR_DB_SERVER:
     1344                psError(PXTOOLS_ERR_PROG, false, "database error");
     1345            default:
     1346                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1347        }
     1348
     1349        return false;
     1350    }
     1351    if (!psArrayLength(output)) {
     1352        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1353        psFree(output);
     1354        return true;
     1355    }
     1356
     1357    if (psArrayLength(output)) {
     1358        // negative simple so the default is true
     1359        if (!ippdbPrintMetadatas(stdout, output, "magicWarpSkyfile", !simple)) {
     1360            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1361            psFree(output);
     1362            return false;
     1363        }
     1364    }
     1365
     1366    psFree(output);
     1367
     1368    return true;
     1369}
     1370
     1371
     1372static bool chipprocessedimfileMode(pxConfig *config)
     1373{
     1374    PS_ASSERT_PTR_NON_NULL(config, false);
     1375
     1376    psMetadata *where = psMetadataAlloc();
     1377    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1378    PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
     1379
     1380    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1381
     1382    psString query = pxDataGet("magictool_chipprocessedimfile.sql");
     1383    if (!query) {
     1384        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1385        return false;
     1386    }
     1387
     1388    if (psListLength(where->list)) {
     1389        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1390        psStringAppend(&query, " AND %s", whereClause);
     1391        psFree(whereClause);
     1392    }
     1393    psFree(where);
     1394
     1395    if (!p_psDBRunQuery(config->dbh, query)) {
     1396        psError(PS_ERR_UNKNOWN, false, "database error");
     1397        psFree(query);
     1398        return false;
     1399    }
     1400    psFree(query);
     1401
     1402    psArray *output = p_psDBFetchResult(config->dbh);
     1403    if (!output) {
     1404        psErrorCode err = psErrorCodeLast();
     1405        switch (err) {
     1406            case PS_ERR_DB_CLIENT:
     1407                psError(PXTOOLS_ERR_SYS, false, "database error");
     1408            case PS_ERR_DB_SERVER:
     1409                psError(PXTOOLS_ERR_PROG, false, "database error");
     1410            default:
     1411                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1412        }
     1413
     1414        return false;
     1415    }
     1416    if (!psArrayLength(output)) {
     1417        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1418        psFree(output);
     1419        return true;
     1420    }
     1421
     1422    if (psArrayLength(output)) {
     1423        // negative simple so the default is true
     1424        if (!ippdbPrintMetadatas(stdout, output, "magicChipProcessedImfile", !simple)) {
     1425            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1426            psFree(output);
     1427            return false;
     1428        }
     1429    }
     1430
     1431    psFree(output);
     1432
     1433    return true;
     1434}
     1435
     1436
     1437static bool rawimfileMode(pxConfig *config)
     1438{
     1439    PS_ASSERT_PTR_NON_NULL(config, false);
     1440
     1441    psMetadata *where = psMetadataAlloc();
     1442    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1443    PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
     1444
     1445    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1446
     1447    psString query = pxDataGet("magictool_rawimfile.sql");
     1448    if (!query) {
     1449        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1450        return false;
     1451    }
     1452
     1453    if (psListLength(where->list)) {
     1454        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1455        psStringAppend(&query, " AND %s", whereClause);
     1456        psFree(whereClause);
     1457    }
     1458    psFree(where);
     1459
     1460    if (!p_psDBRunQuery(config->dbh, query)) {
     1461        psError(PS_ERR_UNKNOWN, false, "database error");
     1462        psFree(query);
     1463        return false;
     1464    }
     1465    psFree(query);
     1466
     1467    psArray *output = p_psDBFetchResult(config->dbh);
     1468    if (!output) {
     1469        psErrorCode err = psErrorCodeLast();
     1470        switch (err) {
     1471            case PS_ERR_DB_CLIENT:
     1472                psError(PXTOOLS_ERR_SYS, false, "database error");
     1473            case PS_ERR_DB_SERVER:
     1474                psError(PXTOOLS_ERR_PROG, false, "database error");
     1475            default:
     1476                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1477        }
     1478
     1479        return false;
     1480    }
     1481    if (!psArrayLength(output)) {
     1482        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1483        psFree(output);
     1484        return true;
     1485    }
     1486
     1487    if (psArrayLength(output)) {
     1488        // negative simple so the default is true
     1489        if (!ippdbPrintMetadatas(stdout, output, "magicRawImfile", !simple)) {
     1490            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1491            psFree(output);
     1492            return false;
     1493        }
     1494    }
     1495
     1496    psFree(output);
     1497
     1498    return true;
     1499}
     1500
     1501
    12341502static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state)
    12351503{

  • trunk/ippTools/src/magictool.h

    r18573 r20700  
    4141    MAGICTOOL_MODE_REVERTMASK,
    4242    MAGICTOOL_MODE_MASK,
     43    MAGICTOOL_MODE_DIFFSKYFILE,
     44    MAGICTOOL_MODE_WARPSKYFILE,
     45    MAGICTOOL_MODE_CHIPPROCESSEDIMFILE,
     46    MAGICTOOL_MODE_RAWIMFILE,
    4347} MAGICtoolMode;
    4448

  • trunk/ippTools/src/magictoolConfig.c

    r18663 r20700  
    151151    psMetadataAddBool(maskArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    152152
     153    // -diffskyfile
     154    psMetadata *diffskyfileArgs = psMetadataAlloc();
     155    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
     156    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
     157    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     158
     159    // -warpskyfile
     160    psMetadata *warpskyfileArgs = psMetadataAlloc();
     161    psMetadataAddS64(warpskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
     162    psMetadataAddBool(warpskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     163
     164    // -chipprocessedimfile
     165    psMetadata *chipprocessedimfileArgs = psMetadataAlloc();
     166    psMetadataAddS64(chipprocessedimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
     167    psMetadataAddStr(chipprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
     168    psMetadataAddBool(chipprocessedimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     169
     170    // -rawimfile
     171    psMetadata *rawimfileArgs = psMetadataAlloc();
     172    psMetadataAddS64(rawimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
     173    psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
     174    psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     175
    153176    psFree(now);
    154177
    … …  
    156179    psMetadata *modes   = psMetadataAlloc();
    157180
    158     PXOPT_ADD_MODE("-definebyquery",   "", MAGICTOOL_MODE_DEFINEBYQUERY,   definebyqueryArgs);
    159     PXOPT_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
    160     PXOPT_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);
    161     PXOPT_ADD_MODE("-addinputskyfile", "", MAGICTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    162     PXOPT_ADD_MODE("-inputskyfile",    "", MAGICTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    163     PXOPT_ADD_MODE("-totree",          "", MAGICTOOL_MODE_TOTREE,          totreeArgs);
    164     PXOPT_ADD_MODE("-inputtree",       "", MAGICTOOL_MODE_INPUTTREE,       inputtreeArgs);
    165     PXOPT_ADD_MODE("-reverttree",      "", MAGICTOOL_MODE_REVERTTREE,      reverttreeArgs);
    166     PXOPT_ADD_MODE("-toprocess",       "", MAGICTOOL_MODE_TOPROCESS,       toprocessArgs);
    167     PXOPT_ADD_MODE("-inputs",          "", MAGICTOOL_MODE_INPUTS,          inputsArgs);
    168     PXOPT_ADD_MODE("-addresult",       "", MAGICTOOL_MODE_ADDRESULT,       addresultArgs);
    169     PXOPT_ADD_MODE("-revertnode",      "", MAGICTOOL_MODE_REVERTNODE,      revertnodeArgs);
    170     PXOPT_ADD_MODE("-tomask",          "", MAGICTOOL_MODE_TOMASK,          tomaskArgs);
    171     PXOPT_ADD_MODE("-addmask",         "", MAGICTOOL_MODE_ADDMASK,         addmaskArgs);
    172     PXOPT_ADD_MODE("-revertmask",      "", MAGICTOOL_MODE_REVERTMASK,      revertmaskArgs);
    173     PXOPT_ADD_MODE("-mask",            "", MAGICTOOL_MODE_MASK,            maskArgs);
     181    PXOPT_ADD_MODE("-definebyquery",       "", MAGICTOOL_MODE_DEFINEBYQUERY,       definebyqueryArgs);
     182    PXOPT_ADD_MODE("-definerun",           "", MAGICTOOL_MODE_DEFINERUN,           definerunArgs);
     183    PXOPT_ADD_MODE("-updaterun",           "", MAGICTOOL_MODE_UPDATERUN,           updaterunArgs);
     184    PXOPT_ADD_MODE("-addinputskyfile",     "", MAGICTOOL_MODE_ADDINPUTSKYFILE,     addinputskyfileArgs);
     185    PXOPT_ADD_MODE("-inputskyfile",        "", MAGICTOOL_MODE_INPUTSKYFILE,        inputskyfileArgs);
     186    PXOPT_ADD_MODE("-totree",              "", MAGICTOOL_MODE_TOTREE,              totreeArgs);
     187    PXOPT_ADD_MODE("-inputtree",           "", MAGICTOOL_MODE_INPUTTREE,           inputtreeArgs);
     188    PXOPT_ADD_MODE("-reverttree",          "", MAGICTOOL_MODE_REVERTTREE,          reverttreeArgs);
     189    PXOPT_ADD_MODE("-toprocess",           "", MAGICTOOL_MODE_TOPROCESS,           toprocessArgs);
     190    PXOPT_ADD_MODE("-inputs",              "", MAGICTOOL_MODE_INPUTS,              inputsArgs);
     191    PXOPT_ADD_MODE("-addresult",           "", MAGICTOOL_MODE_ADDRESULT,           addresultArgs);
     192    PXOPT_ADD_MODE("-revertnode",          "", MAGICTOOL_MODE_REVERTNODE,          revertnodeArgs);
     193    PXOPT_ADD_MODE("-tomask",              "", MAGICTOOL_MODE_TOMASK,              tomaskArgs);
     194    PXOPT_ADD_MODE("-addmask",             "", MAGICTOOL_MODE_ADDMASK,             addmaskArgs);
     195    PXOPT_ADD_MODE("-revertmask",          "", MAGICTOOL_MODE_REVERTMASK,          revertmaskArgs);
     196    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
     197    PXOPT_ADD_MODE("-diffskyfile",         "", MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileArgs);
     198    PXOPT_ADD_MODE("-warpskyfile",         "", MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileArgs);
     199    PXOPT_ADD_MODE("-chipprocessedimfile", "", MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileArgs);
     200    PXOPT_ADD_MODE("-rawimfile",           "", MAGICTOOL_MODE_RAWIMFILE,           rawimfileArgs);
    174201
    175202    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.